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

   1 #pragma warning disable CS1591
   2 using System;
   3 using System.Runtime.InteropServices;
   4 using System.Collections.Generic;
   5 using System.Linq;
   6 using System.Threading;
   7 using System.ComponentModel;
   8 namespace Efl {
   9
  10 namespace Canvas {
  11
  12 /// <summary>Common class for part proxy objects for <see cref="Efl.Canvas.Layout"/>.
  13 /// As an <see cref="Efl.IPart"/> implementation class, all objects of this class are meant to be used for one and only one function call. In pseudo-code, the use of object of this type looks like the following: rect = layout.part(&quot;somepart&quot;).geometry_get();</summary>
  14 [Efl.Canvas.LayoutPartInvalid.NativeMethods]
  15 public class LayoutPartInvalid : Efl.Canvas.LayoutPart, Efl.IContainer, Efl.IContent, Efl.IPack, Efl.IPackLinear, Efl.IPackTable, Efl.IText, Efl.ITextCursor, Efl.ITextMarkup, Efl.ITextMarkupInteractive, Efl.Ui.ILayoutOrientable, Efl.Ui.ILayoutOrientableReadonly
  16 {
  17     ///<summary>Pointer to the native class description.</summary>
  18     public override System.IntPtr NativeClass
  19     {
  20         get
  21         {
  22             if (((object)this).GetType() == typeof(LayoutPartInvalid))
  23             {
  24                 return GetEflClassStatic();
  25             }
  26             else
  27             {
  28                 return Efl.Eo.ClassRegister.klassFromType[((object)this).GetType()];
  29             }
  30         }
  31     }
  32
  33     [System.Runtime.InteropServices.DllImport(efl.Libs.Edje)] internal static extern System.IntPtr
  34         efl_canvas_layout_part_invalid_class_get();
  35     /// <summary>Initializes a new instance of the <see cref="LayoutPartInvalid"/> class.</summary>
  36     /// <param name="parent">Parent instance.</param>
  37     public LayoutPartInvalid(Efl.Object parent= null
  38             ) : base(efl_canvas_layout_part_invalid_class_get(), typeof(LayoutPartInvalid), parent)
  39     {
  40         FinishInstantiation();
  41     }
  42
  43     /// <summary>Initializes a new instance of the <see cref="LayoutPartInvalid"/> class.
  44     /// Internal usage: Constructs an instance from a native pointer. This is used when interacting with C code and should not be used directly.</summary>
  45     /// <param name="raw">The native pointer to be wrapped.</param>
  46     protected LayoutPartInvalid(System.IntPtr raw) : base(raw)
  47     {
  48     }
  49
  50     /// <summary>Initializes a new instance of the <see cref="LayoutPartInvalid"/> class.
  51     /// Internal usage: Constructor to forward the wrapper initialization to the root class that interfaces with native code. Should not be used directly.</summary>
  52     /// <param name="baseKlass">The pointer to the base native Eo class.</param>
  53     /// <param name="managedType">The managed type of the public constructor that originated this call.</param>
  54     /// <param name="parent">The Efl.Object parent of this instance.</param>
  55     protected LayoutPartInvalid(IntPtr baseKlass, System.Type managedType, Efl.Object parent) : base(baseKlass, managedType, parent)
  56     {
  57     }
  58
  59     /// <summary>Sent after a new sub-object was added.
  60     /// (Since EFL 1.22)</summary>
  61     public event EventHandler<Efl.IContainerContentAddedEvt_Args> ContentAddedEvt
  62     {
  63         add
  64         {
  65             lock (eventLock)
  66             {
  67                 Efl.EventCb callerCb = (IntPtr data, ref Efl.Event.NativeStruct evt) =>
  68                 {
  69                     var obj = Efl.Eo.Globals.WrapperSupervisorPtrToManaged(data).Target;
  70                     if (obj != null)
  71                     {
  72                         Efl.IContainerContentAddedEvt_Args args = new Efl.IContainerContentAddedEvt_Args();
  73                         args.arg = (Efl.Eo.Globals.CreateWrapperFor(evt.Info) as Efl.Gfx.IEntityConcrete);
  74                         try
  75                         {
  76                             value?.Invoke(obj, args);
  77                         }
  78                         catch (Exception e)
  79                         {
  80                             Eina.Log.Error(e.ToString());
  81                             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
  82                         }
  83                     }
  84                 };
  85
  86                 string key = "_EFL_CONTAINER_EVENT_CONTENT_ADDED";
  87                 AddNativeEventHandler(efl.Libs.Edje, key, callerCb, value);
  88             }
  89         }
  90
  91         remove
  92         {
  93             lock (eventLock)
  94             {
  95                 string key = "_EFL_CONTAINER_EVENT_CONTENT_ADDED";
  96                 RemoveNativeEventHandler(efl.Libs.Edje, key, value);
  97             }
  98         }
  99     }
 100     ///<summary>Method to raise event ContentAddedEvt.</summary>
 101     public void OnContentAddedEvt(Efl.IContainerContentAddedEvt_Args e)
 102     {
 103         var key = "_EFL_CONTAINER_EVENT_CONTENT_ADDED";
 104         IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Edje, key);
 105         if (desc == IntPtr.Zero)
 106         {
 107             Eina.Log.Error($"Failed to get native event {key}");
 108             return;
 109         }
 110
 111         IntPtr info = e.arg.NativeHandle;
 112         Efl.Eo.Globals.efl_event_callback_call(this.NativeHandle, desc, info);
 113     }
 114     /// <summary>Sent after a sub-object was removed, before unref.
 115     /// (Since EFL 1.22)</summary>
 116     public event EventHandler<Efl.IContainerContentRemovedEvt_Args> ContentRemovedEvt
 117     {
 118         add
 119         {
 120             lock (eventLock)
 121             {
 122                 Efl.EventCb callerCb = (IntPtr data, ref Efl.Event.NativeStruct evt) =>
 123                 {
 124                     var obj = Efl.Eo.Globals.WrapperSupervisorPtrToManaged(data).Target;
 125                     if (obj != null)
 126                     {
 127                         Efl.IContainerContentRemovedEvt_Args args = new Efl.IContainerContentRemovedEvt_Args();
 128                         args.arg = (Efl.Eo.Globals.CreateWrapperFor(evt.Info) as Efl.Gfx.IEntityConcrete);
 129                         try
 130                         {
 131                             value?.Invoke(obj, args);
 132                         }
 133                         catch (Exception e)
 134                         {
 135                             Eina.Log.Error(e.ToString());
 136                             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 137                         }
 138                     }
 139                 };
 140
 141                 string key = "_EFL_CONTAINER_EVENT_CONTENT_REMOVED";
 142                 AddNativeEventHandler(efl.Libs.Edje, key, callerCb, value);
 143             }
 144         }
 145
 146         remove
 147         {
 148             lock (eventLock)
 149             {
 150                 string key = "_EFL_CONTAINER_EVENT_CONTENT_REMOVED";
 151                 RemoveNativeEventHandler(efl.Libs.Edje, key, value);
 152             }
 153         }
 154     }
 155     ///<summary>Method to raise event ContentRemovedEvt.</summary>
 156     public void OnContentRemovedEvt(Efl.IContainerContentRemovedEvt_Args e)
 157     {
 158         var key = "_EFL_CONTAINER_EVENT_CONTENT_REMOVED";
 159         IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Edje, key);
 160         if (desc == IntPtr.Zero)
 161         {
 162             Eina.Log.Error($"Failed to get native event {key}");
 163             return;
 164         }
 165
 166         IntPtr info = e.arg.NativeHandle;
 167         Efl.Eo.Globals.efl_event_callback_call(this.NativeHandle, desc, info);
 168     }
 169     /// <summary>Sent after the content is set or unset using the current content object.
 170     /// (Since EFL 1.22)</summary>
 171     public event EventHandler<Efl.IContentContentChangedEvt_Args> ContentChangedEvt
 172     {
 173         add
 174         {
 175             lock (eventLock)
 176             {
 177                 Efl.EventCb callerCb = (IntPtr data, ref Efl.Event.NativeStruct evt) =>
 178                 {
 179                     var obj = Efl.Eo.Globals.WrapperSupervisorPtrToManaged(data).Target;
 180                     if (obj != null)
 181                     {
 182                         Efl.IContentContentChangedEvt_Args args = new Efl.IContentContentChangedEvt_Args();
 183                         args.arg = (Efl.Eo.Globals.CreateWrapperFor(evt.Info) as Efl.Gfx.IEntityConcrete);
 184                         try
 185                         {
 186                             value?.Invoke(obj, args);
 187                         }
 188                         catch (Exception e)
 189                         {
 190                             Eina.Log.Error(e.ToString());
 191                             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 192                         }
 193                     }
 194                 };
 195
 196                 string key = "_EFL_CONTENT_EVENT_CONTENT_CHANGED";
 197                 AddNativeEventHandler(efl.Libs.Edje, key, callerCb, value);
 198             }
 199         }
 200
 201         remove
 202         {
 203             lock (eventLock)
 204             {
 205                 string key = "_EFL_CONTENT_EVENT_CONTENT_CHANGED";
 206                 RemoveNativeEventHandler(efl.Libs.Edje, key, value);
 207             }
 208         }
 209     }
 210     ///<summary>Method to raise event ContentChangedEvt.</summary>
 211     public void OnContentChangedEvt(Efl.IContentContentChangedEvt_Args e)
 212     {
 213         var key = "_EFL_CONTENT_EVENT_CONTENT_CHANGED";
 214         IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Edje, key);
 215         if (desc == IntPtr.Zero)
 216         {
 217             Eina.Log.Error($"Failed to get native event {key}");
 218             return;
 219         }
 220
 221         IntPtr info = e.arg.NativeHandle;
 222         Efl.Eo.Globals.efl_event_callback_call(this.NativeHandle, desc, info);
 223     }
 224     /// <summary>Begin iterating over this object&apos;s contents.
 225     /// (Since EFL 1.22)</summary>
 226     /// <returns>Iterator on object&apos;s content.</returns>
 227     virtual public Eina.Iterator<Efl.Gfx.IEntity> ContentIterate() {
 228          var _ret_var = Efl.IContainerConcrete.NativeMethods.efl_content_iterate_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 229         Eina.Error.RaiseIfUnhandledException();
 230         return new Eina.Iterator<Efl.Gfx.IEntity>(_ret_var, true, false);
 231  }
 232     /// <summary>Returns the number of contained sub-objects.
 233     /// (Since EFL 1.22)</summary>
 234     /// <returns>Number of sub-objects.</returns>
 235     virtual public int ContentCount() {
 236          var _ret_var = Efl.IContainerConcrete.NativeMethods.efl_content_count_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 237         Eina.Error.RaiseIfUnhandledException();
 238         return _ret_var;
 239  }
 240     /// <summary>Sub-object currently set as this object&apos;s single content.
 241     /// If it is set multiple times, previous sub-objects are removed first. Therefore, if an invalid <c>content</c> is set the object will become empty (it will have no sub-object).
 242     /// (Since EFL 1.22)</summary>
 243     /// <returns>The sub-object.</returns>
 244     virtual public Efl.Gfx.IEntity GetContent() {
 245          var _ret_var = Efl.IContentConcrete.NativeMethods.efl_content_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 246         Eina.Error.RaiseIfUnhandledException();
 247         return _ret_var;
 248  }
 249     /// <summary>Sub-object currently set as this object&apos;s single content.
 250     /// If it is set multiple times, previous sub-objects are removed first. Therefore, if an invalid <c>content</c> is set the object will become empty (it will have no sub-object).
 251     /// (Since EFL 1.22)</summary>
 252     /// <param name="content">The sub-object.</param>
 253     /// <returns><c>true</c> if <c>content</c> was successfully swallowed.</returns>
 254     virtual public bool SetContent(Efl.Gfx.IEntity content) {
 255                                  var _ret_var = Efl.IContentConcrete.NativeMethods.efl_content_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),content);
 256         Eina.Error.RaiseIfUnhandledException();
 257                         return _ret_var;
 258  }
 259     /// <summary>Remove the sub-object currently set as content of this object and return it. This object becomes empty.
 260     /// (Since EFL 1.22)</summary>
 261     /// <returns>Unswallowed object</returns>
 262     virtual public Efl.Gfx.IEntity UnsetContent() {
 263          var _ret_var = Efl.IContentConcrete.NativeMethods.efl_content_unset_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 264         Eina.Error.RaiseIfUnhandledException();
 265         return _ret_var;
 266  }
 267     /// <summary>Removes all packed sub-objects and unreferences them.</summary>
 268     /// <returns><c>true</c> on success, <c>false</c> otherwise.</returns>
 269     virtual public bool ClearPack() {
 270          var _ret_var = Efl.IPackConcrete.NativeMethods.efl_pack_clear_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 271         Eina.Error.RaiseIfUnhandledException();
 272         return _ret_var;
 273  }
 274     /// <summary>Removes all packed sub-objects without unreferencing them.
 275     /// Use with caution.</summary>
 276     /// <returns><c>true</c> on success, <c>false</c> otherwise.</returns>
 277     virtual public bool UnpackAll() {
 278          var _ret_var = Efl.IPackConcrete.NativeMethods.efl_pack_unpack_all_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 279         Eina.Error.RaiseIfUnhandledException();
 280         return _ret_var;
 281  }
 282     /// <summary>Removes an existing sub-object from the container without deleting it.</summary>
 283     /// <param name="subobj">The sub-object to unpack.</param>
 284     /// <returns><c>false</c> if <c>subobj</c> wasn&apos;t in the container or couldn&apos;t be removed.</returns>
 285     virtual public bool Unpack(Efl.Gfx.IEntity subobj) {
 286                                  var _ret_var = Efl.IPackConcrete.NativeMethods.efl_pack_unpack_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),subobj);
 287         Eina.Error.RaiseIfUnhandledException();
 288                         return _ret_var;
 289  }
 290     /// <summary>Adds a sub-object to this container.
 291     /// Depending on the container this will either fill in the default spot, replacing any already existing element or append to the end of the container if there is no default part.
 292     ///
 293     /// When this container is deleted, it will request deletion of the given <c>subobj</c>. Use <see cref="Efl.IPack.Unpack"/> to remove <c>subobj</c> from this container without deleting it.</summary>
 294     /// <param name="subobj">The object to pack.</param>
 295     /// <returns><c>false</c> if <c>subobj</c> could not be packed.</returns>
 296     virtual public bool Pack(Efl.Gfx.IEntity subobj) {
 297                                  var _ret_var = Efl.IPackConcrete.NativeMethods.efl_pack_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),subobj);
 298         Eina.Error.RaiseIfUnhandledException();
 299                         return _ret_var;
 300  }
 301     /// <summary>Prepend an object at the beginning of this container.
 302     /// This is the same as <see cref="Efl.IPackLinear.PackAt"/>(<c>subobj</c>, 0).
 303     ///
 304     /// When this container is deleted, it will request deletion of the given <c>subobj</c>. Use <see cref="Efl.IPack.Unpack"/> to remove <c>subobj</c> from this container without deleting it.</summary>
 305     /// <param name="subobj">Object to pack at the beginning.</param>
 306     /// <returns><c>false</c> if <c>subobj</c> could not be packed.</returns>
 307     virtual public bool PackBegin(Efl.Gfx.IEntity subobj) {
 308                                  var _ret_var = Efl.IPackLinearConcrete.NativeMethods.efl_pack_begin_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),subobj);
 309         Eina.Error.RaiseIfUnhandledException();
 310                         return _ret_var;
 311  }
 312     /// <summary>Append object at the end of this container.
 313     /// This is the same as <see cref="Efl.IPackLinear.PackAt"/>(<c>subobj</c>, -1).
 314     ///
 315     /// When this container is deleted, it will request deletion of the given <c>subobj</c>. Use <see cref="Efl.IPack.Unpack"/> to remove <c>subobj</c> from this container without deleting it.</summary>
 316     /// <param name="subobj">Object to pack at the end.</param>
 317     /// <returns><c>false</c> if <c>subobj</c> could not be packed.</returns>
 318     virtual public bool PackEnd(Efl.Gfx.IEntity subobj) {
 319                                  var _ret_var = Efl.IPackLinearConcrete.NativeMethods.efl_pack_end_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),subobj);
 320         Eina.Error.RaiseIfUnhandledException();
 321                         return _ret_var;
 322  }
 323     /// <summary>Prepend an object before an existing sub-object.
 324     /// When this container is deleted, it will request deletion of the given <c>subobj</c>. Use <see cref="Efl.IPack.Unpack"/> to remove <c>subobj</c> from this container without deleting it.</summary>
 325     /// <param name="subobj">Object to pack before <c>existing</c>.</param>
 326     /// <param name="existing">Existing reference sub-object.</param>
 327     /// <returns><c>false</c> if <c>existing</c> could not be found or <c>subobj</c> could not be packed.</returns>
 328     virtual public bool PackBefore(Efl.Gfx.IEntity subobj, Efl.Gfx.IEntity existing) {
 329                                                          var _ret_var = Efl.IPackLinearConcrete.NativeMethods.efl_pack_before_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),subobj, existing);
 330         Eina.Error.RaiseIfUnhandledException();
 331                                         return _ret_var;
 332  }
 333     /// <summary>Append an object after an existing sub-object.
 334     /// When this container is deleted, it will request deletion of the given <c>subobj</c>. Use <see cref="Efl.IPack.Unpack"/> to remove <c>subobj</c> from this container without deleting it.</summary>
 335     /// <param name="subobj">Object to pack after <c>existing</c>.</param>
 336     /// <param name="existing">Existing reference sub-object.</param>
 337     /// <returns><c>false</c> if <c>existing</c> could not be found or <c>subobj</c> could not be packed.</returns>
 338     virtual public bool PackAfter(Efl.Gfx.IEntity subobj, Efl.Gfx.IEntity existing) {
 339                                                          var _ret_var = Efl.IPackLinearConcrete.NativeMethods.efl_pack_after_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),subobj, existing);
 340         Eina.Error.RaiseIfUnhandledException();
 341                                         return _ret_var;
 342  }
 343     /// <summary>Inserts <c>subobj</c> BEFORE the sub-object at position <c>index</c>.
 344     /// <c>index</c> ranges from -<c>count</c> to <c>count</c>-1, where positive numbers go from first sub-object (0) to last (<c>count</c>-1), and negative numbers go from last sub-object (-1) to first (-<c>count</c>). <c>count</c> is the number of sub-objects currently in the container as returned by <see cref="Efl.IContainer.ContentCount"/>.
 345     ///
 346     /// If <c>index</c> is less than -<c>count</c>, it will trigger <see cref="Efl.IPackLinear.PackBegin"/>(<c>subobj</c>) whereas <c>index</c> greater than <c>count</c>-1 will trigger <see cref="Efl.IPackLinear.PackEnd"/>(<c>subobj</c>).
 347     ///
 348     /// When this container is deleted, it will request deletion of the given <c>subobj</c>. Use <see cref="Efl.IPack.Unpack"/> to remove <c>subobj</c> from this container without deleting it.</summary>
 349     /// <param name="subobj">Object to pack.</param>
 350     /// <param name="index">Index of existing sub-object to insert BEFORE. Valid range is -<c>count</c> to (<c>count</c>-1).</param>
 351     /// <returns><c>false</c> if <c>subobj</c> could not be packed.</returns>
 352     virtual public bool PackAt(Efl.Gfx.IEntity subobj, int index) {
 353                                                          var _ret_var = Efl.IPackLinearConcrete.NativeMethods.efl_pack_at_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),subobj, index);
 354         Eina.Error.RaiseIfUnhandledException();
 355                                         return _ret_var;
 356  }
 357     /// <summary>Sub-object at a given <c>index</c> in this container.
 358     /// <c>index</c> ranges from -<c>count</c> to <c>count</c>-1, where positive numbers go from first sub-object (0) to last (<c>count</c>-1), and negative numbers go from last sub-object (-1) to first (-<c>count</c>). <c>count</c> is the number of sub-objects currently in the container as returned by <see cref="Efl.IContainer.ContentCount"/>.
 359     ///
 360     /// If <c>index</c> is less than -<c>count</c>, it will return the first sub-object whereas <c>index</c> greater than <c>count</c>-1 will return the last sub-object.</summary>
 361     /// <param name="index">Index of the existing sub-object to retrieve. Valid range is -<c>count</c> to (<c>count</c>-1).</param>
 362     /// <returns>The sub-object contained at the given <c>index</c>.</returns>
 363     virtual public Efl.Gfx.IEntity GetPackContent(int index) {
 364                                  var _ret_var = Efl.IPackLinearConcrete.NativeMethods.efl_pack_content_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),index);
 365         Eina.Error.RaiseIfUnhandledException();
 366                         return _ret_var;
 367  }
 368     /// <summary>Get the index of a sub-object in this container.</summary>
 369     /// <param name="subobj">An existing sub-object in this container.</param>
 370     /// <returns>-1 in case <c>subobj</c> is not found, or the index of <c>subobj</c> in the range 0 to (<c>count</c>-1).</returns>
 371     virtual public int GetPackIndex(Efl.Gfx.IEntity subobj) {
 372                                  var _ret_var = Efl.IPackLinearConcrete.NativeMethods.efl_pack_index_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),subobj);
 373         Eina.Error.RaiseIfUnhandledException();
 374                         return _ret_var;
 375  }
 376     /// <summary>Pop out (remove) the sub-object at the specified <c>index</c>.
 377     /// <c>index</c> ranges from -<c>count</c> to <c>count</c>-1, where positive numbers go from first sub-object (0) to last (<c>count</c>-1), and negative numbers go from last sub-object (-1) to first (-<c>count</c>). <c>count</c> is the number of sub-objects currently in the container as returned by <see cref="Efl.IContainer.ContentCount"/>.
 378     ///
 379     /// If <c>index</c> is less than -<c>count</c>, it will remove the first sub-object whereas <c>index</c> greater than <c>count</c>-1 will remove the last sub-object.</summary>
 380     /// <param name="index">Index of the sub-object to remove. Valid range is -<c>count</c> to (<c>count</c>-1).</param>
 381     /// <returns>The sub-object if it could be removed.</returns>
 382     virtual public Efl.Gfx.IEntity PackUnpackAt(int index) {
 383                                  var _ret_var = Efl.IPackLinearConcrete.NativeMethods.efl_pack_unpack_at_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),index);
 384         Eina.Error.RaiseIfUnhandledException();
 385                         return _ret_var;
 386  }
 387     /// <summary>Position and span of the <c>subobj</c> in this container, may be modified to move the <c>subobj</c></summary>
 388     /// <param name="subobj">Child object</param>
 389     /// <param name="col">Column number</param>
 390     /// <param name="row">Row number</param>
 391     /// <param name="colspan">Column span</param>
 392     /// <param name="rowspan">Row span</param>
 393     /// <returns>Returns false if item is not a child</returns>
 394     virtual public bool GetTablePosition(Efl.Gfx.IEntity subobj, out int col, out int row, out int colspan, out int rowspan) {
 395                                                                                                                                  var _ret_var = Efl.IPackTableConcrete.NativeMethods.efl_pack_table_position_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),subobj, out col, out row, out colspan, out rowspan);
 396         Eina.Error.RaiseIfUnhandledException();
 397                                                                                         return _ret_var;
 398  }
 399     /// <summary>Combines <see cref="Efl.IPackTable.TableColumns"/> and <see cref="Efl.IPackTable.TableRows"/></summary>
 400     /// <param name="cols">Number of columns</param>
 401     /// <param name="rows">Number of rows</param>
 402     virtual public void GetTableSize(out int cols, out int rows) {
 403                                                          Efl.IPackTableConcrete.NativeMethods.efl_pack_table_size_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),out cols, out rows);
 404         Eina.Error.RaiseIfUnhandledException();
 405                                          }
 406     /// <summary>Combines <see cref="Efl.IPackTable.TableColumns"/> and <see cref="Efl.IPackTable.TableRows"/></summary>
 407     /// <param name="cols">Number of columns</param>
 408     /// <param name="rows">Number of rows</param>
 409     virtual public void SetTableSize(int cols, int rows) {
 410                                                          Efl.IPackTableConcrete.NativeMethods.efl_pack_table_size_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),cols, rows);
 411         Eina.Error.RaiseIfUnhandledException();
 412                                          }
 413     /// <summary>Specifies the amount of columns the table will have when the fill direction is horizontal. If it is vertical, the amount of columns depends on the amount of cells added and <see cref="Efl.IPackTable.TableRows"/>.</summary>
 414     /// <returns>Amount of columns.</returns>
 415     virtual public int GetTableColumns() {
 416          var _ret_var = Efl.IPackTableConcrete.NativeMethods.efl_pack_table_columns_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 417         Eina.Error.RaiseIfUnhandledException();
 418         return _ret_var;
 419  }
 420     /// <summary>Specifies the amount of columns the table will have when the fill direction is horizontal. If it is vertical, the amount of columns depends on the amount of cells added and <see cref="Efl.IPackTable.TableRows"/>.</summary>
 421     /// <param name="cols">Amount of columns.</param>
 422     virtual public void SetTableColumns(int cols) {
 423                                  Efl.IPackTableConcrete.NativeMethods.efl_pack_table_columns_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),cols);
 424         Eina.Error.RaiseIfUnhandledException();
 425                          }
 426     /// <summary>Specifies the amount of rows the table will have when the fill direction is vertical. If it is horizontal, the amount of rows depends on the amount of cells added and <see cref="Efl.IPackTable.TableColumns"/>.</summary>
 427     /// <returns>Amount of rows.</returns>
 428     virtual public int GetTableRows() {
 429          var _ret_var = Efl.IPackTableConcrete.NativeMethods.efl_pack_table_rows_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 430         Eina.Error.RaiseIfUnhandledException();
 431         return _ret_var;
 432  }
 433     /// <summary>Specifies the amount of rows the table will have when the fill direction is vertical. If it is horizontal, the amount of rows depends on the amount of cells added and <see cref="Efl.IPackTable.TableColumns"/>.</summary>
 434     /// <param name="rows">Amount of rows.</param>
 435     virtual public void SetTableRows(int rows) {
 436                                  Efl.IPackTableConcrete.NativeMethods.efl_pack_table_rows_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),rows);
 437         Eina.Error.RaiseIfUnhandledException();
 438                          }
 439     /// <summary>Pack object at a given location in the table.
 440     /// When this container is deleted, it will request deletion of the given <c>subobj</c>. Use <see cref="Efl.IPack.Unpack"/> to remove <c>subobj</c> from this container without deleting it.</summary>
 441     /// <param name="subobj">A child object to pack in this table.</param>
 442     /// <param name="col">Column number</param>
 443     /// <param name="row">Row number</param>
 444     /// <param name="colspan">0 means 1, -1 means <see cref="Efl.IPackTable.TableColumns"/></param>
 445     /// <param name="rowspan">0 means 1, -1 means <see cref="Efl.IPackTable.TableRows"/></param>
 446     /// <returns><c>true</c> on success, <c>false</c> otherwise</returns>
 447     virtual public bool PackTable(Efl.Gfx.IEntity subobj, int col, int row, int colspan, int rowspan) {
 448                                                                                                                                  var _ret_var = Efl.IPackTableConcrete.NativeMethods.efl_pack_table_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),subobj, col, row, colspan, rowspan);
 449         Eina.Error.RaiseIfUnhandledException();
 450                                                                                         return _ret_var;
 451  }
 452     /// <summary>Returns all objects at a given position in this table.</summary>
 453     /// <param name="col">Column number</param>
 454     /// <param name="row">Row number</param>
 455     /// <param name="below">If <c>true</c> get objects spanning over this cell.</param>
 456     /// <returns>Iterator to table contents</returns>
 457     virtual public Eina.Iterator<Efl.Gfx.IEntity> GetTableContents(int col, int row, bool below) {
 458                                                                                  var _ret_var = Efl.IPackTableConcrete.NativeMethods.efl_pack_table_contents_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),col, row, below);
 459         Eina.Error.RaiseIfUnhandledException();
 460                                                         return new Eina.Iterator<Efl.Gfx.IEntity>(_ret_var, true, false);
 461  }
 462     /// <summary>Returns a child at a given position, see <see cref="Efl.IPackTable.GetTableContents"/>.</summary>
 463     /// <param name="col">Column number</param>
 464     /// <param name="row">Row number</param>
 465     /// <returns>Child object</returns>
 466     virtual public Efl.Gfx.IEntity GetTableContent(int col, int row) {
 467                                                          var _ret_var = Efl.IPackTableConcrete.NativeMethods.efl_pack_table_content_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),col, row);
 468         Eina.Error.RaiseIfUnhandledException();
 469                                         return _ret_var;
 470  }
 471     /// <summary>Retrieves the text string currently being displayed by the given text object.
 472     /// Do not free() the return value.
 473     ///
 474     /// See also <see cref="Efl.IText.GetText"/>.
 475     /// (Since EFL 1.22)</summary>
 476     /// <returns>Text string to display on it.</returns>
 477     virtual public System.String GetText() {
 478          var _ret_var = Efl.ITextConcrete.NativeMethods.efl_text_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 479         Eina.Error.RaiseIfUnhandledException();
 480         return _ret_var;
 481  }
 482     /// <summary>Sets the text string to be displayed by the given text object.
 483     /// See also <see cref="Efl.IText.GetText"/>.
 484     /// (Since EFL 1.22)</summary>
 485     /// <param name="text">Text string to display on it.</param>
 486     virtual public void SetText(System.String text) {
 487                                  Efl.ITextConcrete.NativeMethods.efl_text_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),text);
 488         Eina.Error.RaiseIfUnhandledException();
 489                          }
 490     /// <summary>The object&apos;s main cursor.</summary>
 491     /// <param name="get_type">Cursor type</param>
 492     /// <returns>Text cursor object</returns>
 493     virtual public Efl.TextCursorCursor GetTextCursor(Efl.TextCursorGetType get_type) {
 494                                  var _ret_var = Efl.ITextCursorConcrete.NativeMethods.efl_text_cursor_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),get_type);
 495         Eina.Error.RaiseIfUnhandledException();
 496                         return _ret_var;
 497  }
 498     /// <summary>Cursor position</summary>
 499     /// <param name="cur">Cursor object</param>
 500     /// <returns>Cursor position</returns>
 501     virtual public int GetCursorPosition(Efl.TextCursorCursor cur) {
 502                                  var _ret_var = Efl.ITextCursorConcrete.NativeMethods.efl_text_cursor_position_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),cur);
 503         Eina.Error.RaiseIfUnhandledException();
 504                         return _ret_var;
 505  }
 506     /// <summary>Cursor position</summary>
 507     /// <param name="cur">Cursor object</param>
 508     /// <param name="position">Cursor position</param>
 509     virtual public void SetCursorPosition(Efl.TextCursorCursor cur, int position) {
 510                                                          Efl.ITextCursorConcrete.NativeMethods.efl_text_cursor_position_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),cur, position);
 511         Eina.Error.RaiseIfUnhandledException();
 512                                          }
 513     /// <summary>The content of the cursor (the character under the cursor)</summary>
 514     /// <param name="cur">Cursor object</param>
 515     /// <returns>The unicode codepoint of the character</returns>
 516     virtual public Eina.Unicode GetCursorContent(Efl.TextCursorCursor cur) {
 517                                  var _ret_var = Efl.ITextCursorConcrete.NativeMethods.efl_text_cursor_content_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),cur);
 518         Eina.Error.RaiseIfUnhandledException();
 519                         return _ret_var;
 520  }
 521     /// <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.
 522     /// 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>
 523     /// <param name="cur">Cursor object</param>
 524     /// <param name="ctype">The type of the cursor.</param>
 525     /// <param name="cx">The x of the cursor (or upper cursor)</param>
 526     /// <param name="cy">The y of the cursor (or upper cursor)</param>
 527     /// <param name="cw">The width of the cursor (or upper cursor)</param>
 528     /// <param name="ch">The height of the cursor (or upper cursor)</param>
 529     /// <param name="cx2">The x of the lower cursor</param>
 530     /// <param name="cy2">The y of the lower cursor</param>
 531     /// <param name="cw2">The width of the lower cursor</param>
 532     /// <param name="ch2">The height of the lower cursor</param>
 533     /// <returns><c>true</c> if split cursor, <c>false</c> otherwise.</returns>
 534     virtual public bool GetCursorGeometry(Efl.TextCursorCursor cur, Efl.TextCursorType ctype, out int cx, out int cy, out int cw, out int ch, out int cx2, out int cy2, out int cw2, out int ch2) {
 535                                                                                                                                                                                                                                                          var _ret_var = Efl.ITextCursorConcrete.NativeMethods.efl_text_cursor_geometry_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),cur, ctype, out cx, out cy, out cw, out ch, out cx2, out cy2, out cw2, out ch2);
 536         Eina.Error.RaiseIfUnhandledException();
 537                                                                                                                                                                         return _ret_var;
 538  }
 539     /// <summary>Create new cursor</summary>
 540     /// <returns>Cursor object</returns>
 541     virtual public Efl.TextCursorCursor NewCursor() {
 542          var _ret_var = Efl.ITextCursorConcrete.NativeMethods.efl_text_cursor_new_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 543         Eina.Error.RaiseIfUnhandledException();
 544         return _ret_var;
 545  }
 546     /// <summary>Free existing cursor</summary>
 547     /// <param name="cur">Cursor object</param>
 548     virtual public void CursorFree(Efl.TextCursorCursor cur) {
 549                                  Efl.ITextCursorConcrete.NativeMethods.efl_text_cursor_free_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),cur);
 550         Eina.Error.RaiseIfUnhandledException();
 551                          }
 552     /// <summary>Check if two cursors are equal</summary>
 553     /// <param name="cur1">Cursor 1 object</param>
 554     /// <param name="cur2">Cursor 2 object</param>
 555     /// <returns><c>true</c> if cursors are equal, <c>false</c> otherwise</returns>
 556     virtual public bool CursorEqual(Efl.TextCursorCursor cur1, Efl.TextCursorCursor cur2) {
 557                                                          var _ret_var = Efl.ITextCursorConcrete.NativeMethods.efl_text_cursor_equal_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),cur1, cur2);
 558         Eina.Error.RaiseIfUnhandledException();
 559                                         return _ret_var;
 560  }
 561     /// <summary>Compare two cursors</summary>
 562     /// <param name="cur1">Cursor 1 object</param>
 563     /// <param name="cur2">Cursor 2 object</param>
 564     /// <returns>Difference between cursors</returns>
 565     virtual public int CursorCompare(Efl.TextCursorCursor cur1, Efl.TextCursorCursor cur2) {
 566                                                          var _ret_var = Efl.ITextCursorConcrete.NativeMethods.efl_text_cursor_compare_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),cur1, cur2);
 567         Eina.Error.RaiseIfUnhandledException();
 568                                         return _ret_var;
 569  }
 570     /// <summary>Copy existing cursor</summary>
 571     /// <param name="dst">Destination cursor</param>
 572     /// <param name="src">Source cursor</param>
 573     virtual public void CursorCopy(Efl.TextCursorCursor dst, Efl.TextCursorCursor src) {
 574                                                          Efl.ITextCursorConcrete.NativeMethods.efl_text_cursor_copy_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),dst, src);
 575         Eina.Error.RaiseIfUnhandledException();
 576                                          }
 577     /// <summary>Advances to the next character</summary>
 578     /// <param name="cur">Cursor object</param>
 579     virtual public void CursorCharNext(Efl.TextCursorCursor cur) {
 580                                  Efl.ITextCursorConcrete.NativeMethods.efl_text_cursor_char_next_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),cur);
 581         Eina.Error.RaiseIfUnhandledException();
 582                          }
 583     /// <summary>Advances to the previous character</summary>
 584     /// <param name="cur">Cursor object</param>
 585     virtual public void CursorCharPrev(Efl.TextCursorCursor cur) {
 586                                  Efl.ITextCursorConcrete.NativeMethods.efl_text_cursor_char_prev_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),cur);
 587         Eina.Error.RaiseIfUnhandledException();
 588                          }
 589     /// <summary>Advances to the next grapheme cluster</summary>
 590     /// <param name="cur">Cursor object</param>
 591     virtual public void CursorClusterNext(Efl.TextCursorCursor cur) {
 592                                  Efl.ITextCursorConcrete.NativeMethods.efl_text_cursor_cluster_next_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),cur);
 593         Eina.Error.RaiseIfUnhandledException();
 594                          }
 595     /// <summary>Advances to the previous grapheme cluster</summary>
 596     /// <param name="cur">Cursor object</param>
 597     virtual public void CursorClusterPrev(Efl.TextCursorCursor cur) {
 598                                  Efl.ITextCursorConcrete.NativeMethods.efl_text_cursor_cluster_prev_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),cur);
 599         Eina.Error.RaiseIfUnhandledException();
 600                          }
 601     /// <summary>Advances to the first character in this paragraph</summary>
 602     /// <param name="cur">Cursor object</param>
 603     virtual public void CursorParagraphCharFirst(Efl.TextCursorCursor cur) {
 604                                  Efl.ITextCursorConcrete.NativeMethods.efl_text_cursor_paragraph_char_first_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),cur);
 605         Eina.Error.RaiseIfUnhandledException();
 606                          }
 607     /// <summary>Advances to the last character in this paragraph</summary>
 608     /// <param name="cur">Cursor object</param>
 609     virtual public void CursorParagraphCharLast(Efl.TextCursorCursor cur) {
 610                                  Efl.ITextCursorConcrete.NativeMethods.efl_text_cursor_paragraph_char_last_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),cur);
 611         Eina.Error.RaiseIfUnhandledException();
 612                          }
 613     /// <summary>Advance to current word start</summary>
 614     /// <param name="cur">Cursor object</param>
 615     virtual public void CursorWordStart(Efl.TextCursorCursor cur) {
 616                                  Efl.ITextCursorConcrete.NativeMethods.efl_text_cursor_word_start_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),cur);
 617         Eina.Error.RaiseIfUnhandledException();
 618                          }
 619     /// <summary>Advance to current word end</summary>
 620     /// <param name="cur">Cursor object</param>
 621     virtual public void CursorWordEnd(Efl.TextCursorCursor cur) {
 622                                  Efl.ITextCursorConcrete.NativeMethods.efl_text_cursor_word_end_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),cur);
 623         Eina.Error.RaiseIfUnhandledException();
 624                          }
 625     /// <summary>Advance to current line first character</summary>
 626     /// <param name="cur">Cursor object</param>
 627     virtual public void CursorLineCharFirst(Efl.TextCursorCursor cur) {
 628                                  Efl.ITextCursorConcrete.NativeMethods.efl_text_cursor_line_char_first_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),cur);
 629         Eina.Error.RaiseIfUnhandledException();
 630                          }
 631     /// <summary>Advance to current line last character</summary>
 632     /// <param name="cur">Cursor object</param>
 633     virtual public void CursorLineCharLast(Efl.TextCursorCursor cur) {
 634                                  Efl.ITextCursorConcrete.NativeMethods.efl_text_cursor_line_char_last_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),cur);
 635         Eina.Error.RaiseIfUnhandledException();
 636                          }
 637     /// <summary>Advance to current paragraph first character</summary>
 638     /// <param name="cur">Cursor object</param>
 639     virtual public void CursorParagraphFirst(Efl.TextCursorCursor cur) {
 640                                  Efl.ITextCursorConcrete.NativeMethods.efl_text_cursor_paragraph_first_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),cur);
 641         Eina.Error.RaiseIfUnhandledException();
 642                          }
 643     /// <summary>Advance to current paragraph last character</summary>
 644     /// <param name="cur">Cursor object</param>
 645     virtual public void CursorParagraphLast(Efl.TextCursorCursor cur) {
 646                                  Efl.ITextCursorConcrete.NativeMethods.efl_text_cursor_paragraph_last_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),cur);
 647         Eina.Error.RaiseIfUnhandledException();
 648                          }
 649     /// <summary>Advances to the start of the next text node</summary>
 650     /// <param name="cur">Cursor object</param>
 651     virtual public void CursorParagraphNext(Efl.TextCursorCursor cur) {
 652                                  Efl.ITextCursorConcrete.NativeMethods.efl_text_cursor_paragraph_next_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),cur);
 653         Eina.Error.RaiseIfUnhandledException();
 654                          }
 655     /// <summary>Advances to the end of the previous text node</summary>
 656     /// <param name="cur">Cursor object</param>
 657     virtual public void CursorParagraphPrev(Efl.TextCursorCursor cur) {
 658                                  Efl.ITextCursorConcrete.NativeMethods.efl_text_cursor_paragraph_prev_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),cur);
 659         Eina.Error.RaiseIfUnhandledException();
 660                          }
 661     /// <summary>Jump the cursor by the given number of lines</summary>
 662     /// <param name="cur">Cursor object</param>
 663     /// <param name="by">Number of lines</param>
 664     virtual public void CursorLineJumpBy(Efl.TextCursorCursor cur, int by) {
 665                                                          Efl.ITextCursorConcrete.NativeMethods.efl_text_cursor_line_jump_by_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),cur, by);
 666         Eina.Error.RaiseIfUnhandledException();
 667                                          }
 668     /// <summary>Set cursor coordinates</summary>
 669     /// <param name="cur">Cursor object</param>
 670     /// <param name="x">X coord to set by.</param>
 671     /// <param name="y">Y coord to set by.</param>
 672     virtual public void SetCursorCoord(Efl.TextCursorCursor cur, int x, int y) {
 673                                                                                  Efl.ITextCursorConcrete.NativeMethods.efl_text_cursor_coord_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),cur, x, y);
 674         Eina.Error.RaiseIfUnhandledException();
 675                                                          }
 676     /// <summary>Set cursor coordinates according to grapheme clusters. It does not allow to put a cursor to the middle of a grapheme cluster.</summary>
 677     /// <param name="cur">Cursor object</param>
 678     /// <param name="x">X coord to set by.</param>
 679     /// <param name="y">Y coord to set by.</param>
 680     virtual public void SetCursorClusterCoord(Efl.TextCursorCursor cur, int x, int y) {
 681                                                                                  Efl.ITextCursorConcrete.NativeMethods.efl_text_cursor_cluster_coord_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),cur, x, y);
 682         Eina.Error.RaiseIfUnhandledException();
 683                                                          }
 684     /// <summary>Adds text to the current cursor position and set the cursor to *after* the start of the text just added.</summary>
 685     /// <param name="cur">Cursor object</param>
 686     /// <param name="text">Text to append (UTF-8 format).</param>
 687     /// <returns>Length of the appended text.</returns>
 688     virtual public int CursorTextInsert(Efl.TextCursorCursor cur, System.String text) {
 689                                                          var _ret_var = Efl.ITextCursorConcrete.NativeMethods.efl_text_cursor_text_insert_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),cur, text);
 690         Eina.Error.RaiseIfUnhandledException();
 691                                         return _ret_var;
 692  }
 693     /// <summary>Deletes a single character from position pointed by given cursor.</summary>
 694     /// <param name="cur">Cursor object</param>
 695     virtual public void CursorCharDelete(Efl.TextCursorCursor cur) {
 696                                  Efl.ITextCursorConcrete.NativeMethods.efl_text_cursor_char_delete_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),cur);
 697         Eina.Error.RaiseIfUnhandledException();
 698                          }
 699     /// <summary>Markup property</summary>
 700     /// <returns>The markup-text representation set to this text.</returns>
 701     virtual public System.String GetMarkup() {
 702          var _ret_var = Efl.ITextMarkupConcrete.NativeMethods.efl_text_markup_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 703         Eina.Error.RaiseIfUnhandledException();
 704         return _ret_var;
 705  }
 706     /// <summary>Markup property</summary>
 707     /// <param name="markup">The markup-text representation set to this text.</param>
 708     virtual public void SetMarkup(System.String markup) {
 709                                  Efl.ITextMarkupConcrete.NativeMethods.efl_text_markup_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),markup);
 710         Eina.Error.RaiseIfUnhandledException();
 711                          }
 712     /// <summary>Markup of a given range in the text</summary>
 713     /// <param name="start">Start of the markup region</param>
 714     /// <param name="end">End of markup region</param>
 715     /// <returns>The markup-text representation set to this text of a given range</returns>
 716     virtual public System.String GetMarkupRange(Efl.TextCursorCursor start, Efl.TextCursorCursor end) {
 717                                                          var _ret_var = Efl.ITextMarkupInteractiveConcrete.NativeMethods.efl_text_markup_interactive_markup_range_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),start, end);
 718         Eina.Error.RaiseIfUnhandledException();
 719                                         return _ret_var;
 720  }
 721     /// <summary>Markup of a given range in the text</summary>
 722     /// <param name="start">Start of the markup region</param>
 723     /// <param name="end">End of markup region</param>
 724     /// <param name="markup">The markup-text representation set to this text of a given range</param>
 725     virtual public void SetMarkupRange(Efl.TextCursorCursor start, Efl.TextCursorCursor end, System.String markup) {
 726                                                                                  Efl.ITextMarkupInteractiveConcrete.NativeMethods.efl_text_markup_interactive_markup_range_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),start, end, markup);
 727         Eina.Error.RaiseIfUnhandledException();
 728                                                          }
 729     /// <summary>Inserts a markup text to the text object in a given cursor position</summary>
 730     /// <param name="cur">Cursor position to insert markup</param>
 731     /// <param name="markup">The markup text to insert</param>
 732     virtual public void CursorMarkupInsert(Efl.TextCursorCursor cur, System.String markup) {
 733                                                          Efl.ITextMarkupInteractiveConcrete.NativeMethods.efl_text_markup_interactive_cursor_markup_insert_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),cur, markup);
 734         Eina.Error.RaiseIfUnhandledException();
 735                                          }
 736     /// <summary>Control the direction of a given widget.
 737     /// Use this function to change how your widget is to be disposed: vertically or horizontally or inverted vertically or inverted horizontally.
 738     ///
 739     /// Mirroring as defined in <see cref="Efl.Ui.II18n"/> can invert the <c>horizontal</c> direction: it is <c>ltr</c> by default, but becomes <c>rtl</c> if the object is mirrored.</summary>
 740     /// <returns>Direction of the widget.</returns>
 741     virtual public Efl.Ui.LayoutOrientation GetOrientation() {
 742          var _ret_var = Efl.Ui.ILayoutOrientableConcrete.NativeMethods.efl_ui_layout_orientation_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 743         Eina.Error.RaiseIfUnhandledException();
 744         return _ret_var;
 745  }
 746     /// <summary>Control the direction of a given widget.
 747     /// Use this function to change how your widget is to be disposed: vertically or horizontally or inverted vertically or inverted horizontally.
 748     ///
 749     /// Mirroring as defined in <see cref="Efl.Ui.II18n"/> can invert the <c>horizontal</c> direction: it is <c>ltr</c> by default, but becomes <c>rtl</c> if the object is mirrored.</summary>
 750     /// <param name="dir">Direction of the widget.</param>
 751     virtual public void SetOrientation(Efl.Ui.LayoutOrientation dir) {
 752                                  Efl.Ui.ILayoutOrientableConcrete.NativeMethods.efl_ui_layout_orientation_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),dir);
 753         Eina.Error.RaiseIfUnhandledException();
 754                          }
 755     /// <summary>Sub-object currently set as this object&apos;s single content.
 756     /// If it is set multiple times, previous sub-objects are removed first. Therefore, if an invalid <c>content</c> is set the object will become empty (it will have no sub-object).
 757     /// (Since EFL 1.22)</summary>
 758     /// <value>The sub-object.</value>
 759     public Efl.Gfx.IEntity Content {
 760         get { return GetContent(); }
 761         set { SetContent(value); }
 762     }
 763     /// <summary>Specifies the amount of columns the table will have when the fill direction is horizontal. If it is vertical, the amount of columns depends on the amount of cells added and <see cref="Efl.IPackTable.TableRows"/>.</summary>
 764     /// <value>Amount of columns.</value>
 765     public int TableColumns {
 766         get { return GetTableColumns(); }
 767         set { SetTableColumns(value); }
 768     }
 769     /// <summary>Specifies the amount of rows the table will have when the fill direction is vertical. If it is horizontal, the amount of rows depends on the amount of cells added and <see cref="Efl.IPackTable.TableColumns"/>.</summary>
 770     /// <value>Amount of rows.</value>
 771     public int TableRows {
 772         get { return GetTableRows(); }
 773         set { SetTableRows(value); }
 774     }
 775     /// <summary>Markup property</summary>
 776     /// <value>The markup-text representation set to this text.</value>
 777     public System.String Markup {
 778         get { return GetMarkup(); }
 779         set { SetMarkup(value); }
 780     }
 781     /// <summary>Control the direction of a given widget.
 782     /// Use this function to change how your widget is to be disposed: vertically or horizontally or inverted vertically or inverted horizontally.
 783     ///
 784     /// Mirroring as defined in <see cref="Efl.Ui.II18n"/> can invert the <c>horizontal</c> direction: it is <c>ltr</c> by default, but becomes <c>rtl</c> if the object is mirrored.</summary>
 785     /// <value>Direction of the widget.</value>
 786     public Efl.Ui.LayoutOrientation Orientation {
 787         get { return GetOrientation(); }
 788         set { SetOrientation(value); }
 789     }
 790     private static IntPtr GetEflClassStatic()
 791     {
 792         return Efl.Canvas.LayoutPartInvalid.efl_canvas_layout_part_invalid_class_get();
 793     }
 794     /// <summary>Wrapper for native methods and virtual method delegates.
 795     /// For internal use by generated code only.</summary>
 796     public new class NativeMethods : Efl.Canvas.LayoutPart.NativeMethods
 797     {
 798         private static Efl.Eo.NativeModule Module = new Efl.Eo.NativeModule(    efl.Libs.Edje);
 799         /// <summary>Gets the list of Eo operations to override.</summary>
 800         /// <returns>The list of Eo operations to be overload.</returns>
 801         public override System.Collections.Generic.List<Efl_Op_Description> GetEoOps(System.Type type)
 802         {
 803             var descs = new System.Collections.Generic.List<Efl_Op_Description>();
 804             var methods = Efl.Eo.Globals.GetUserMethods(type);
 805
 806             if (efl_content_iterate_static_delegate == null)
 807             {
 808                 efl_content_iterate_static_delegate = new efl_content_iterate_delegate(content_iterate);
 809             }
 810
 811             if (methods.FirstOrDefault(m => m.Name == "ContentIterate") != null)
 812             {
 813                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_content_iterate"), func = Marshal.GetFunctionPointerForDelegate(efl_content_iterate_static_delegate) });
 814             }
 815
 816             if (efl_content_count_static_delegate == null)
 817             {
 818                 efl_content_count_static_delegate = new efl_content_count_delegate(content_count);
 819             }
 820
 821             if (methods.FirstOrDefault(m => m.Name == "ContentCount") != null)
 822             {
 823                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_content_count"), func = Marshal.GetFunctionPointerForDelegate(efl_content_count_static_delegate) });
 824             }
 825
 826             if (efl_content_get_static_delegate == null)
 827             {
 828                 efl_content_get_static_delegate = new efl_content_get_delegate(content_get);
 829             }
 830
 831             if (methods.FirstOrDefault(m => m.Name == "GetContent") != null)
 832             {
 833                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_content_get"), func = Marshal.GetFunctionPointerForDelegate(efl_content_get_static_delegate) });
 834             }
 835
 836             if (efl_content_set_static_delegate == null)
 837             {
 838                 efl_content_set_static_delegate = new efl_content_set_delegate(content_set);
 839             }
 840
 841             if (methods.FirstOrDefault(m => m.Name == "SetContent") != null)
 842             {
 843                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_content_set"), func = Marshal.GetFunctionPointerForDelegate(efl_content_set_static_delegate) });
 844             }
 845
 846             if (efl_content_unset_static_delegate == null)
 847             {
 848                 efl_content_unset_static_delegate = new efl_content_unset_delegate(content_unset);
 849             }
 850
 851             if (methods.FirstOrDefault(m => m.Name == "UnsetContent") != null)
 852             {
 853                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_content_unset"), func = Marshal.GetFunctionPointerForDelegate(efl_content_unset_static_delegate) });
 854             }
 855
 856             if (efl_pack_clear_static_delegate == null)
 857             {
 858                 efl_pack_clear_static_delegate = new efl_pack_clear_delegate(pack_clear);
 859             }
 860
 861             if (methods.FirstOrDefault(m => m.Name == "ClearPack") != null)
 862             {
 863                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_pack_clear"), func = Marshal.GetFunctionPointerForDelegate(efl_pack_clear_static_delegate) });
 864             }
 865
 866             if (efl_pack_unpack_all_static_delegate == null)
 867             {
 868                 efl_pack_unpack_all_static_delegate = new efl_pack_unpack_all_delegate(unpack_all);
 869             }
 870
 871             if (methods.FirstOrDefault(m => m.Name == "UnpackAll") != null)
 872             {
 873                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_pack_unpack_all"), func = Marshal.GetFunctionPointerForDelegate(efl_pack_unpack_all_static_delegate) });
 874             }
 875
 876             if (efl_pack_unpack_static_delegate == null)
 877             {
 878                 efl_pack_unpack_static_delegate = new efl_pack_unpack_delegate(unpack);
 879             }
 880
 881             if (methods.FirstOrDefault(m => m.Name == "Unpack") != null)
 882             {
 883                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_pack_unpack"), func = Marshal.GetFunctionPointerForDelegate(efl_pack_unpack_static_delegate) });
 884             }
 885
 886             if (efl_pack_static_delegate == null)
 887             {
 888                 efl_pack_static_delegate = new efl_pack_delegate(pack);
 889             }
 890
 891             if (methods.FirstOrDefault(m => m.Name == "Pack") != null)
 892             {
 893                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_pack"), func = Marshal.GetFunctionPointerForDelegate(efl_pack_static_delegate) });
 894             }
 895
 896             if (efl_pack_begin_static_delegate == null)
 897             {
 898                 efl_pack_begin_static_delegate = new efl_pack_begin_delegate(pack_begin);
 899             }
 900
 901             if (methods.FirstOrDefault(m => m.Name == "PackBegin") != null)
 902             {
 903                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_pack_begin"), func = Marshal.GetFunctionPointerForDelegate(efl_pack_begin_static_delegate) });
 904             }
 905
 906             if (efl_pack_end_static_delegate == null)
 907             {
 908                 efl_pack_end_static_delegate = new efl_pack_end_delegate(pack_end);
 909             }
 910
 911             if (methods.FirstOrDefault(m => m.Name == "PackEnd") != null)
 912             {
 913                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_pack_end"), func = Marshal.GetFunctionPointerForDelegate(efl_pack_end_static_delegate) });
 914             }
 915
 916             if (efl_pack_before_static_delegate == null)
 917             {
 918                 efl_pack_before_static_delegate = new efl_pack_before_delegate(pack_before);
 919             }
 920
 921             if (methods.FirstOrDefault(m => m.Name == "PackBefore") != null)
 922             {
 923                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_pack_before"), func = Marshal.GetFunctionPointerForDelegate(efl_pack_before_static_delegate) });
 924             }
 925
 926             if (efl_pack_after_static_delegate == null)
 927             {
 928                 efl_pack_after_static_delegate = new efl_pack_after_delegate(pack_after);
 929             }
 930
 931             if (methods.FirstOrDefault(m => m.Name == "PackAfter") != null)
 932             {
 933                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_pack_after"), func = Marshal.GetFunctionPointerForDelegate(efl_pack_after_static_delegate) });
 934             }
 935
 936             if (efl_pack_at_static_delegate == null)
 937             {
 938                 efl_pack_at_static_delegate = new efl_pack_at_delegate(pack_at);
 939             }
 940
 941             if (methods.FirstOrDefault(m => m.Name == "PackAt") != null)
 942             {
 943                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_pack_at"), func = Marshal.GetFunctionPointerForDelegate(efl_pack_at_static_delegate) });
 944             }
 945
 946             if (efl_pack_content_get_static_delegate == null)
 947             {
 948                 efl_pack_content_get_static_delegate = new efl_pack_content_get_delegate(pack_content_get);
 949             }
 950
 951             if (methods.FirstOrDefault(m => m.Name == "GetPackContent") != null)
 952             {
 953                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_pack_content_get"), func = Marshal.GetFunctionPointerForDelegate(efl_pack_content_get_static_delegate) });
 954             }
 955
 956             if (efl_pack_index_get_static_delegate == null)
 957             {
 958                 efl_pack_index_get_static_delegate = new efl_pack_index_get_delegate(pack_index_get);
 959             }
 960
 961             if (methods.FirstOrDefault(m => m.Name == "GetPackIndex") != null)
 962             {
 963                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_pack_index_get"), func = Marshal.GetFunctionPointerForDelegate(efl_pack_index_get_static_delegate) });
 964             }
 965
 966             if (efl_pack_unpack_at_static_delegate == null)
 967             {
 968                 efl_pack_unpack_at_static_delegate = new efl_pack_unpack_at_delegate(pack_unpack_at);
 969             }
 970
 971             if (methods.FirstOrDefault(m => m.Name == "PackUnpackAt") != null)
 972             {
 973                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_pack_unpack_at"), func = Marshal.GetFunctionPointerForDelegate(efl_pack_unpack_at_static_delegate) });
 974             }
 975
 976             if (efl_pack_table_position_get_static_delegate == null)
 977             {
 978                 efl_pack_table_position_get_static_delegate = new efl_pack_table_position_get_delegate(table_position_get);
 979             }
 980
 981             if (methods.FirstOrDefault(m => m.Name == "GetTablePosition") != null)
 982             {
 983                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_pack_table_position_get"), func = Marshal.GetFunctionPointerForDelegate(efl_pack_table_position_get_static_delegate) });
 984             }
 985
 986             if (efl_pack_table_size_get_static_delegate == null)
 987             {
 988                 efl_pack_table_size_get_static_delegate = new efl_pack_table_size_get_delegate(table_size_get);
 989             }
 990
 991             if (methods.FirstOrDefault(m => m.Name == "GetTableSize") != null)
 992             {
 993                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_pack_table_size_get"), func = Marshal.GetFunctionPointerForDelegate(efl_pack_table_size_get_static_delegate) });
 994             }
 995
 996             if (efl_pack_table_size_set_static_delegate == null)
 997             {
 998                 efl_pack_table_size_set_static_delegate = new efl_pack_table_size_set_delegate(table_size_set);
 999             }
1000
1001             if (methods.FirstOrDefault(m => m.Name == "SetTableSize") != null)
1002             {
1003                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_pack_table_size_set"), func = Marshal.GetFunctionPointerForDelegate(efl_pack_table_size_set_static_delegate) });
1004             }
1005
1006             if (efl_pack_table_columns_get_static_delegate == null)
1007             {
1008                 efl_pack_table_columns_get_static_delegate = new efl_pack_table_columns_get_delegate(table_columns_get);
1009             }
1010
1011             if (methods.FirstOrDefault(m => m.Name == "GetTableColumns") != null)
1012             {
1013                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_pack_table_columns_get"), func = Marshal.GetFunctionPointerForDelegate(efl_pack_table_columns_get_static_delegate) });
1014             }
1015
1016             if (efl_pack_table_columns_set_static_delegate == null)
1017             {
1018                 efl_pack_table_columns_set_static_delegate = new efl_pack_table_columns_set_delegate(table_columns_set);
1019             }
1020
1021             if (methods.FirstOrDefault(m => m.Name == "SetTableColumns") != null)
1022             {
1023                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_pack_table_columns_set"), func = Marshal.GetFunctionPointerForDelegate(efl_pack_table_columns_set_static_delegate) });
1024             }
1025
1026             if (efl_pack_table_rows_get_static_delegate == null)
1027             {
1028                 efl_pack_table_rows_get_static_delegate = new efl_pack_table_rows_get_delegate(table_rows_get);
1029             }
1030
1031             if (methods.FirstOrDefault(m => m.Name == "GetTableRows") != null)
1032             {
1033                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_pack_table_rows_get"), func = Marshal.GetFunctionPointerForDelegate(efl_pack_table_rows_get_static_delegate) });
1034             }
1035
1036             if (efl_pack_table_rows_set_static_delegate == null)
1037             {
1038                 efl_pack_table_rows_set_static_delegate = new efl_pack_table_rows_set_delegate(table_rows_set);
1039             }
1040
1041             if (methods.FirstOrDefault(m => m.Name == "SetTableRows") != null)
1042             {
1043                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_pack_table_rows_set"), func = Marshal.GetFunctionPointerForDelegate(efl_pack_table_rows_set_static_delegate) });
1044             }
1045
1046             if (efl_pack_table_static_delegate == null)
1047             {
1048                 efl_pack_table_static_delegate = new efl_pack_table_delegate(pack_table);
1049             }
1050
1051             if (methods.FirstOrDefault(m => m.Name == "PackTable") != null)
1052             {
1053                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_pack_table"), func = Marshal.GetFunctionPointerForDelegate(efl_pack_table_static_delegate) });
1054             }
1055
1056             if (efl_pack_table_contents_get_static_delegate == null)
1057             {
1058                 efl_pack_table_contents_get_static_delegate = new efl_pack_table_contents_get_delegate(table_contents_get);
1059             }
1060
1061             if (methods.FirstOrDefault(m => m.Name == "GetTableContents") != null)
1062             {
1063                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_pack_table_contents_get"), func = Marshal.GetFunctionPointerForDelegate(efl_pack_table_contents_get_static_delegate) });
1064             }
1065
1066             if (efl_pack_table_content_get_static_delegate == null)
1067             {
1068                 efl_pack_table_content_get_static_delegate = new efl_pack_table_content_get_delegate(table_content_get);
1069             }
1070
1071             if (methods.FirstOrDefault(m => m.Name == "GetTableContent") != null)
1072             {
1073                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_pack_table_content_get"), func = Marshal.GetFunctionPointerForDelegate(efl_pack_table_content_get_static_delegate) });
1074             }
1075
1076             if (efl_text_get_static_delegate == null)
1077             {
1078                 efl_text_get_static_delegate = new efl_text_get_delegate(text_get);
1079             }
1080
1081             if (methods.FirstOrDefault(m => m.Name == "GetText") != null)
1082             {
1083                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_text_get"), func = Marshal.GetFunctionPointerForDelegate(efl_text_get_static_delegate) });
1084             }
1085
1086             if (efl_text_set_static_delegate == null)
1087             {
1088                 efl_text_set_static_delegate = new efl_text_set_delegate(text_set);
1089             }
1090
1091             if (methods.FirstOrDefault(m => m.Name == "SetText") != null)
1092             {
1093                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_text_set"), func = Marshal.GetFunctionPointerForDelegate(efl_text_set_static_delegate) });
1094             }
1095
1096             if (efl_text_cursor_get_static_delegate == null)
1097             {
1098                 efl_text_cursor_get_static_delegate = new efl_text_cursor_get_delegate(text_cursor_get);
1099             }
1100
1101             if (methods.FirstOrDefault(m => m.Name == "GetTextCursor") != null)
1102             {
1103                 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) });
1104             }
1105
1106             if (efl_text_cursor_position_get_static_delegate == null)
1107             {
1108                 efl_text_cursor_position_get_static_delegate = new efl_text_cursor_position_get_delegate(cursor_position_get);
1109             }
1110
1111             if (methods.FirstOrDefault(m => m.Name == "GetCursorPosition") != null)
1112             {
1113                 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) });
1114             }
1115
1116             if (efl_text_cursor_position_set_static_delegate == null)
1117             {
1118                 efl_text_cursor_position_set_static_delegate = new efl_text_cursor_position_set_delegate(cursor_position_set);
1119             }
1120
1121             if (methods.FirstOrDefault(m => m.Name == "SetCursorPosition") != null)
1122             {
1123                 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) });
1124             }
1125
1126             if (efl_text_cursor_content_get_static_delegate == null)
1127             {
1128                 efl_text_cursor_content_get_static_delegate = new efl_text_cursor_content_get_delegate(cursor_content_get);
1129             }
1130
1131             if (methods.FirstOrDefault(m => m.Name == "GetCursorContent") != null)
1132             {
1133                 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) });
1134             }
1135
1136             if (efl_text_cursor_geometry_get_static_delegate == null)
1137             {
1138                 efl_text_cursor_geometry_get_static_delegate = new efl_text_cursor_geometry_get_delegate(cursor_geometry_get);
1139             }
1140
1141             if (methods.FirstOrDefault(m => m.Name == "GetCursorGeometry") != null)
1142             {
1143                 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) });
1144             }
1145
1146             if (efl_text_cursor_new_static_delegate == null)
1147             {
1148                 efl_text_cursor_new_static_delegate = new efl_text_cursor_new_delegate(cursor_new);
1149             }
1150
1151             if (methods.FirstOrDefault(m => m.Name == "NewCursor") != null)
1152             {
1153                 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) });
1154             }
1155
1156             if (efl_text_cursor_free_static_delegate == null)
1157             {
1158                 efl_text_cursor_free_static_delegate = new efl_text_cursor_free_delegate(cursor_free);
1159             }
1160
1161             if (methods.FirstOrDefault(m => m.Name == "CursorFree") != null)
1162             {
1163                 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) });
1164             }
1165
1166             if (efl_text_cursor_equal_static_delegate == null)
1167             {
1168                 efl_text_cursor_equal_static_delegate = new efl_text_cursor_equal_delegate(cursor_equal);
1169             }
1170
1171             if (methods.FirstOrDefault(m => m.Name == "CursorEqual") != null)
1172             {
1173                 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) });
1174             }
1175
1176             if (efl_text_cursor_compare_static_delegate == null)
1177             {
1178                 efl_text_cursor_compare_static_delegate = new efl_text_cursor_compare_delegate(cursor_compare);
1179             }
1180
1181             if (methods.FirstOrDefault(m => m.Name == "CursorCompare") != null)
1182             {
1183                 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) });
1184             }
1185
1186             if (efl_text_cursor_copy_static_delegate == null)
1187             {
1188                 efl_text_cursor_copy_static_delegate = new efl_text_cursor_copy_delegate(cursor_copy);
1189             }
1190
1191             if (methods.FirstOrDefault(m => m.Name == "CursorCopy") != null)
1192             {
1193                 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) });
1194             }
1195
1196             if (efl_text_cursor_char_next_static_delegate == null)
1197             {
1198                 efl_text_cursor_char_next_static_delegate = new efl_text_cursor_char_next_delegate(cursor_char_next);
1199             }
1200
1201             if (methods.FirstOrDefault(m => m.Name == "CursorCharNext") != null)
1202             {
1203                 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) });
1204             }
1205
1206             if (efl_text_cursor_char_prev_static_delegate == null)
1207             {
1208                 efl_text_cursor_char_prev_static_delegate = new efl_text_cursor_char_prev_delegate(cursor_char_prev);
1209             }
1210
1211             if (methods.FirstOrDefault(m => m.Name == "CursorCharPrev") != null)
1212             {
1213                 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) });
1214             }
1215
1216             if (efl_text_cursor_cluster_next_static_delegate == null)
1217             {
1218                 efl_text_cursor_cluster_next_static_delegate = new efl_text_cursor_cluster_next_delegate(cursor_cluster_next);
1219             }
1220
1221             if (methods.FirstOrDefault(m => m.Name == "CursorClusterNext") != null)
1222             {
1223                 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) });
1224             }
1225
1226             if (efl_text_cursor_cluster_prev_static_delegate == null)
1227             {
1228                 efl_text_cursor_cluster_prev_static_delegate = new efl_text_cursor_cluster_prev_delegate(cursor_cluster_prev);
1229             }
1230
1231             if (methods.FirstOrDefault(m => m.Name == "CursorClusterPrev") != null)
1232             {
1233                 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) });
1234             }
1235
1236             if (efl_text_cursor_paragraph_char_first_static_delegate == null)
1237             {
1238                 efl_text_cursor_paragraph_char_first_static_delegate = new efl_text_cursor_paragraph_char_first_delegate(cursor_paragraph_char_first);
1239             }
1240
1241             if (methods.FirstOrDefault(m => m.Name == "CursorParagraphCharFirst") != null)
1242             {
1243                 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) });
1244             }
1245
1246             if (efl_text_cursor_paragraph_char_last_static_delegate == null)
1247             {
1248                 efl_text_cursor_paragraph_char_last_static_delegate = new efl_text_cursor_paragraph_char_last_delegate(cursor_paragraph_char_last);
1249             }
1250
1251             if (methods.FirstOrDefault(m => m.Name == "CursorParagraphCharLast") != null)
1252             {
1253                 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) });
1254             }
1255
1256             if (efl_text_cursor_word_start_static_delegate == null)
1257             {
1258                 efl_text_cursor_word_start_static_delegate = new efl_text_cursor_word_start_delegate(cursor_word_start);
1259             }
1260
1261             if (methods.FirstOrDefault(m => m.Name == "CursorWordStart") != null)
1262             {
1263                 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) });
1264             }
1265
1266             if (efl_text_cursor_word_end_static_delegate == null)
1267             {
1268                 efl_text_cursor_word_end_static_delegate = new efl_text_cursor_word_end_delegate(cursor_word_end);
1269             }
1270
1271             if (methods.FirstOrDefault(m => m.Name == "CursorWordEnd") != null)
1272             {
1273                 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) });
1274             }
1275
1276             if (efl_text_cursor_line_char_first_static_delegate == null)
1277             {
1278                 efl_text_cursor_line_char_first_static_delegate = new efl_text_cursor_line_char_first_delegate(cursor_line_char_first);
1279             }
1280
1281             if (methods.FirstOrDefault(m => m.Name == "CursorLineCharFirst") != null)
1282             {
1283                 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) });
1284             }
1285
1286             if (efl_text_cursor_line_char_last_static_delegate == null)
1287             {
1288                 efl_text_cursor_line_char_last_static_delegate = new efl_text_cursor_line_char_last_delegate(cursor_line_char_last);
1289             }
1290
1291             if (methods.FirstOrDefault(m => m.Name == "CursorLineCharLast") != null)
1292             {
1293                 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) });
1294             }
1295
1296             if (efl_text_cursor_paragraph_first_static_delegate == null)
1297             {
1298                 efl_text_cursor_paragraph_first_static_delegate = new efl_text_cursor_paragraph_first_delegate(cursor_paragraph_first);
1299             }
1300
1301             if (methods.FirstOrDefault(m => m.Name == "CursorParagraphFirst") != null)
1302             {
1303                 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) });
1304             }
1305
1306             if (efl_text_cursor_paragraph_last_static_delegate == null)
1307             {
1308                 efl_text_cursor_paragraph_last_static_delegate = new efl_text_cursor_paragraph_last_delegate(cursor_paragraph_last);
1309             }
1310
1311             if (methods.FirstOrDefault(m => m.Name == "CursorParagraphLast") != null)
1312             {
1313                 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) });
1314             }
1315
1316             if (efl_text_cursor_paragraph_next_static_delegate == null)
1317             {
1318                 efl_text_cursor_paragraph_next_static_delegate = new efl_text_cursor_paragraph_next_delegate(cursor_paragraph_next);
1319             }
1320
1321             if (methods.FirstOrDefault(m => m.Name == "CursorParagraphNext") != null)
1322             {
1323                 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) });
1324             }
1325
1326             if (efl_text_cursor_paragraph_prev_static_delegate == null)
1327             {
1328                 efl_text_cursor_paragraph_prev_static_delegate = new efl_text_cursor_paragraph_prev_delegate(cursor_paragraph_prev);
1329             }
1330
1331             if (methods.FirstOrDefault(m => m.Name == "CursorParagraphPrev") != null)
1332             {
1333                 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) });
1334             }
1335
1336             if (efl_text_cursor_line_jump_by_static_delegate == null)
1337             {
1338                 efl_text_cursor_line_jump_by_static_delegate = new efl_text_cursor_line_jump_by_delegate(cursor_line_jump_by);
1339             }
1340
1341             if (methods.FirstOrDefault(m => m.Name == "CursorLineJumpBy") != null)
1342             {
1343                 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) });
1344             }
1345
1346             if (efl_text_cursor_coord_set_static_delegate == null)
1347             {
1348                 efl_text_cursor_coord_set_static_delegate = new efl_text_cursor_coord_set_delegate(cursor_coord_set);
1349             }
1350
1351             if (methods.FirstOrDefault(m => m.Name == "SetCursorCoord") != null)
1352             {
1353                 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) });
1354             }
1355
1356             if (efl_text_cursor_cluster_coord_set_static_delegate == null)
1357             {
1358                 efl_text_cursor_cluster_coord_set_static_delegate = new efl_text_cursor_cluster_coord_set_delegate(cursor_cluster_coord_set);
1359             }
1360
1361             if (methods.FirstOrDefault(m => m.Name == "SetCursorClusterCoord") != null)
1362             {
1363                 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) });
1364             }
1365
1366             if (efl_text_cursor_text_insert_static_delegate == null)
1367             {
1368                 efl_text_cursor_text_insert_static_delegate = new efl_text_cursor_text_insert_delegate(cursor_text_insert);
1369             }
1370
1371             if (methods.FirstOrDefault(m => m.Name == "CursorTextInsert") != null)
1372             {
1373                 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) });
1374             }
1375
1376             if (efl_text_cursor_char_delete_static_delegate == null)
1377             {
1378                 efl_text_cursor_char_delete_static_delegate = new efl_text_cursor_char_delete_delegate(cursor_char_delete);
1379             }
1380
1381             if (methods.FirstOrDefault(m => m.Name == "CursorCharDelete") != null)
1382             {
1383                 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) });
1384             }
1385
1386             if (efl_text_markup_get_static_delegate == null)
1387             {
1388                 efl_text_markup_get_static_delegate = new efl_text_markup_get_delegate(markup_get);
1389             }
1390
1391             if (methods.FirstOrDefault(m => m.Name == "GetMarkup") != null)
1392             {
1393                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_text_markup_get"), func = Marshal.GetFunctionPointerForDelegate(efl_text_markup_get_static_delegate) });
1394             }
1395
1396             if (efl_text_markup_set_static_delegate == null)
1397             {
1398                 efl_text_markup_set_static_delegate = new efl_text_markup_set_delegate(markup_set);
1399             }
1400
1401             if (methods.FirstOrDefault(m => m.Name == "SetMarkup") != null)
1402             {
1403                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_text_markup_set"), func = Marshal.GetFunctionPointerForDelegate(efl_text_markup_set_static_delegate) });
1404             }
1405
1406             if (efl_text_markup_interactive_markup_range_get_static_delegate == null)
1407             {
1408                 efl_text_markup_interactive_markup_range_get_static_delegate = new efl_text_markup_interactive_markup_range_get_delegate(markup_range_get);
1409             }
1410
1411             if (methods.FirstOrDefault(m => m.Name == "GetMarkupRange") != null)
1412             {
1413                 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) });
1414             }
1415
1416             if (efl_text_markup_interactive_markup_range_set_static_delegate == null)
1417             {
1418                 efl_text_markup_interactive_markup_range_set_static_delegate = new efl_text_markup_interactive_markup_range_set_delegate(markup_range_set);
1419             }
1420
1421             if (methods.FirstOrDefault(m => m.Name == "SetMarkupRange") != null)
1422             {
1423                 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) });
1424             }
1425
1426             if (efl_text_markup_interactive_cursor_markup_insert_static_delegate == null)
1427             {
1428                 efl_text_markup_interactive_cursor_markup_insert_static_delegate = new efl_text_markup_interactive_cursor_markup_insert_delegate(cursor_markup_insert);
1429             }
1430
1431             if (methods.FirstOrDefault(m => m.Name == "CursorMarkupInsert") != null)
1432             {
1433                 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) });
1434             }
1435
1436             if (efl_ui_layout_orientation_get_static_delegate == null)
1437             {
1438                 efl_ui_layout_orientation_get_static_delegate = new efl_ui_layout_orientation_get_delegate(orientation_get);
1439             }
1440
1441             if (methods.FirstOrDefault(m => m.Name == "GetOrientation") != null)
1442             {
1443                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_ui_layout_orientation_get"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_layout_orientation_get_static_delegate) });
1444             }
1445
1446             if (efl_ui_layout_orientation_set_static_delegate == null)
1447             {
1448                 efl_ui_layout_orientation_set_static_delegate = new efl_ui_layout_orientation_set_delegate(orientation_set);
1449             }
1450
1451             if (methods.FirstOrDefault(m => m.Name == "SetOrientation") != null)
1452             {
1453                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_ui_layout_orientation_set"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_layout_orientation_set_static_delegate) });
1454             }
1455
1456             descs.AddRange(base.GetEoOps(type));
1457             return descs;
1458         }
1459         /// <summary>Returns the Eo class for the native methods of this class.</summary>
1460         /// <returns>The native class pointer.</returns>
1461         public override IntPtr GetEflClass()
1462         {
1463             return Efl.Canvas.LayoutPartInvalid.efl_canvas_layout_part_invalid_class_get();
1464         }
1465
1466         #pragma warning disable CA1707, CS1591, SA1300, SA1600
1467
1468
1469         private delegate System.IntPtr efl_content_iterate_delegate(System.IntPtr obj, System.IntPtr pd);
1470
1471
1472         public delegate System.IntPtr efl_content_iterate_api_delegate(System.IntPtr obj);
1473
1474         public static Efl.Eo.FunctionWrapper<efl_content_iterate_api_delegate> efl_content_iterate_ptr = new Efl.Eo.FunctionWrapper<efl_content_iterate_api_delegate>(Module, "efl_content_iterate");
1475
1476         private static System.IntPtr content_iterate(System.IntPtr obj, System.IntPtr pd)
1477         {
1478             Eina.Log.Debug("function efl_content_iterate was called");
1479             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1480             if (ws != null)
1481             {
1482             Eina.Iterator<Efl.Gfx.IEntity> _ret_var = default(Eina.Iterator<Efl.Gfx.IEntity>);
1483                 try
1484                 {
1485                     _ret_var = ((LayoutPartInvalid)ws.Target).ContentIterate();
1486                 }
1487                 catch (Exception e)
1488                 {
1489                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1490                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1491                 }
1492
1493         _ret_var.Own = false; return _ret_var.Handle;
1494
1495             }
1496             else
1497             {
1498                 return efl_content_iterate_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
1499             }
1500         }
1501
1502         private static efl_content_iterate_delegate efl_content_iterate_static_delegate;
1503
1504
1505         private delegate int efl_content_count_delegate(System.IntPtr obj, System.IntPtr pd);
1506
1507
1508         public delegate int efl_content_count_api_delegate(System.IntPtr obj);
1509
1510         public static Efl.Eo.FunctionWrapper<efl_content_count_api_delegate> efl_content_count_ptr = new Efl.Eo.FunctionWrapper<efl_content_count_api_delegate>(Module, "efl_content_count");
1511
1512         private static int content_count(System.IntPtr obj, System.IntPtr pd)
1513         {
1514             Eina.Log.Debug("function efl_content_count was called");
1515             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1516             if (ws != null)
1517             {
1518             int _ret_var = default(int);
1519                 try
1520                 {
1521                     _ret_var = ((LayoutPartInvalid)ws.Target).ContentCount();
1522                 }
1523                 catch (Exception e)
1524                 {
1525                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1526                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1527                 }
1528
1529         return _ret_var;
1530
1531             }
1532             else
1533             {
1534                 return efl_content_count_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
1535             }
1536         }
1537
1538         private static efl_content_count_delegate efl_content_count_static_delegate;
1539
1540         [return:MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))]
1541         private delegate Efl.Gfx.IEntity efl_content_get_delegate(System.IntPtr obj, System.IntPtr pd);
1542
1543         [return:MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))]
1544         public delegate Efl.Gfx.IEntity efl_content_get_api_delegate(System.IntPtr obj);
1545
1546         public static Efl.Eo.FunctionWrapper<efl_content_get_api_delegate> efl_content_get_ptr = new Efl.Eo.FunctionWrapper<efl_content_get_api_delegate>(Module, "efl_content_get");
1547
1548         private static Efl.Gfx.IEntity content_get(System.IntPtr obj, System.IntPtr pd)
1549         {
1550             Eina.Log.Debug("function efl_content_get was called");
1551             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1552             if (ws != null)
1553             {
1554             Efl.Gfx.IEntity _ret_var = default(Efl.Gfx.IEntity);
1555                 try
1556                 {
1557                     _ret_var = ((LayoutPartInvalid)ws.Target).GetContent();
1558                 }
1559                 catch (Exception e)
1560                 {
1561                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1562                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1563                 }
1564
1565         return _ret_var;
1566
1567             }
1568             else
1569             {
1570                 return efl_content_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
1571             }
1572         }
1573
1574         private static efl_content_get_delegate efl_content_get_static_delegate;
1575
1576         [return: MarshalAs(UnmanagedType.U1)]
1577         private delegate bool efl_content_set_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))] Efl.Gfx.IEntity content);
1578
1579         [return: MarshalAs(UnmanagedType.U1)]
1580         public delegate bool efl_content_set_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))] Efl.Gfx.IEntity content);
1581
1582         public static Efl.Eo.FunctionWrapper<efl_content_set_api_delegate> efl_content_set_ptr = new Efl.Eo.FunctionWrapper<efl_content_set_api_delegate>(Module, "efl_content_set");
1583
1584         private static bool content_set(System.IntPtr obj, System.IntPtr pd, Efl.Gfx.IEntity content)
1585         {
1586             Eina.Log.Debug("function efl_content_set was called");
1587             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1588             if (ws != null)
1589             {
1590                                     bool _ret_var = default(bool);
1591                 try
1592                 {
1593                     _ret_var = ((LayoutPartInvalid)ws.Target).SetContent(content);
1594                 }
1595                 catch (Exception e)
1596                 {
1597                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1598                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1599                 }
1600
1601                         return _ret_var;
1602
1603             }
1604             else
1605             {
1606                 return efl_content_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), content);
1607             }
1608         }
1609
1610         private static efl_content_set_delegate efl_content_set_static_delegate;
1611
1612         [return:MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))]
1613         private delegate Efl.Gfx.IEntity efl_content_unset_delegate(System.IntPtr obj, System.IntPtr pd);
1614
1615         [return:MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))]
1616         public delegate Efl.Gfx.IEntity efl_content_unset_api_delegate(System.IntPtr obj);
1617
1618         public static Efl.Eo.FunctionWrapper<efl_content_unset_api_delegate> efl_content_unset_ptr = new Efl.Eo.FunctionWrapper<efl_content_unset_api_delegate>(Module, "efl_content_unset");
1619
1620         private static Efl.Gfx.IEntity content_unset(System.IntPtr obj, System.IntPtr pd)
1621         {
1622             Eina.Log.Debug("function efl_content_unset was called");
1623             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1624             if (ws != null)
1625             {
1626             Efl.Gfx.IEntity _ret_var = default(Efl.Gfx.IEntity);
1627                 try
1628                 {
1629                     _ret_var = ((LayoutPartInvalid)ws.Target).UnsetContent();
1630                 }
1631                 catch (Exception e)
1632                 {
1633                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1634                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1635                 }
1636
1637         return _ret_var;
1638
1639             }
1640             else
1641             {
1642                 return efl_content_unset_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
1643             }
1644         }
1645
1646         private static efl_content_unset_delegate efl_content_unset_static_delegate;
1647
1648         [return: MarshalAs(UnmanagedType.U1)]
1649         private delegate bool efl_pack_clear_delegate(System.IntPtr obj, System.IntPtr pd);
1650
1651         [return: MarshalAs(UnmanagedType.U1)]
1652         public delegate bool efl_pack_clear_api_delegate(System.IntPtr obj);
1653
1654         public static Efl.Eo.FunctionWrapper<efl_pack_clear_api_delegate> efl_pack_clear_ptr = new Efl.Eo.FunctionWrapper<efl_pack_clear_api_delegate>(Module, "efl_pack_clear");
1655
1656         private static bool pack_clear(System.IntPtr obj, System.IntPtr pd)
1657         {
1658             Eina.Log.Debug("function efl_pack_clear was called");
1659             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1660             if (ws != null)
1661             {
1662             bool _ret_var = default(bool);
1663                 try
1664                 {
1665                     _ret_var = ((LayoutPartInvalid)ws.Target).ClearPack();
1666                 }
1667                 catch (Exception e)
1668                 {
1669                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1670                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1671                 }
1672
1673         return _ret_var;
1674
1675             }
1676             else
1677             {
1678                 return efl_pack_clear_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
1679             }
1680         }
1681
1682         private static efl_pack_clear_delegate efl_pack_clear_static_delegate;
1683
1684         [return: MarshalAs(UnmanagedType.U1)]
1685         private delegate bool efl_pack_unpack_all_delegate(System.IntPtr obj, System.IntPtr pd);
1686
1687         [return: MarshalAs(UnmanagedType.U1)]
1688         public delegate bool efl_pack_unpack_all_api_delegate(System.IntPtr obj);
1689
1690         public static Efl.Eo.FunctionWrapper<efl_pack_unpack_all_api_delegate> efl_pack_unpack_all_ptr = new Efl.Eo.FunctionWrapper<efl_pack_unpack_all_api_delegate>(Module, "efl_pack_unpack_all");
1691
1692         private static bool unpack_all(System.IntPtr obj, System.IntPtr pd)
1693         {
1694             Eina.Log.Debug("function efl_pack_unpack_all was called");
1695             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1696             if (ws != null)
1697             {
1698             bool _ret_var = default(bool);
1699                 try
1700                 {
1701                     _ret_var = ((LayoutPartInvalid)ws.Target).UnpackAll();
1702                 }
1703                 catch (Exception e)
1704                 {
1705                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1706                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1707                 }
1708
1709         return _ret_var;
1710
1711             }
1712             else
1713             {
1714                 return efl_pack_unpack_all_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
1715             }
1716         }
1717
1718         private static efl_pack_unpack_all_delegate efl_pack_unpack_all_static_delegate;
1719
1720         [return: MarshalAs(UnmanagedType.U1)]
1721         private delegate bool efl_pack_unpack_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))] Efl.Gfx.IEntity subobj);
1722
1723         [return: MarshalAs(UnmanagedType.U1)]
1724         public delegate bool efl_pack_unpack_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))] Efl.Gfx.IEntity subobj);
1725
1726         public static Efl.Eo.FunctionWrapper<efl_pack_unpack_api_delegate> efl_pack_unpack_ptr = new Efl.Eo.FunctionWrapper<efl_pack_unpack_api_delegate>(Module, "efl_pack_unpack");
1727
1728         private static bool unpack(System.IntPtr obj, System.IntPtr pd, Efl.Gfx.IEntity subobj)
1729         {
1730             Eina.Log.Debug("function efl_pack_unpack was called");
1731             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1732             if (ws != null)
1733             {
1734                                     bool _ret_var = default(bool);
1735                 try
1736                 {
1737                     _ret_var = ((LayoutPartInvalid)ws.Target).Unpack(subobj);
1738                 }
1739                 catch (Exception e)
1740                 {
1741                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1742                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1743                 }
1744
1745                         return _ret_var;
1746
1747             }
1748             else
1749             {
1750                 return efl_pack_unpack_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), subobj);
1751             }
1752         }
1753
1754         private static efl_pack_unpack_delegate efl_pack_unpack_static_delegate;
1755
1756         [return: MarshalAs(UnmanagedType.U1)]
1757         private delegate bool efl_pack_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))] Efl.Gfx.IEntity subobj);
1758
1759         [return: MarshalAs(UnmanagedType.U1)]
1760         public delegate bool efl_pack_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))] Efl.Gfx.IEntity subobj);
1761
1762         public static Efl.Eo.FunctionWrapper<efl_pack_api_delegate> efl_pack_ptr = new Efl.Eo.FunctionWrapper<efl_pack_api_delegate>(Module, "efl_pack");
1763
1764         private static bool pack(System.IntPtr obj, System.IntPtr pd, Efl.Gfx.IEntity subobj)
1765         {
1766             Eina.Log.Debug("function efl_pack was called");
1767             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1768             if (ws != null)
1769             {
1770                                     bool _ret_var = default(bool);
1771                 try
1772                 {
1773                     _ret_var = ((LayoutPartInvalid)ws.Target).Pack(subobj);
1774                 }
1775                 catch (Exception e)
1776                 {
1777                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1778                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1779                 }
1780
1781                         return _ret_var;
1782
1783             }
1784             else
1785             {
1786                 return efl_pack_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), subobj);
1787             }
1788         }
1789
1790         private static efl_pack_delegate efl_pack_static_delegate;
1791
1792         [return: MarshalAs(UnmanagedType.U1)]
1793         private delegate bool efl_pack_begin_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))] Efl.Gfx.IEntity subobj);
1794
1795         [return: MarshalAs(UnmanagedType.U1)]
1796         public delegate bool efl_pack_begin_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))] Efl.Gfx.IEntity subobj);
1797
1798         public static Efl.Eo.FunctionWrapper<efl_pack_begin_api_delegate> efl_pack_begin_ptr = new Efl.Eo.FunctionWrapper<efl_pack_begin_api_delegate>(Module, "efl_pack_begin");
1799
1800         private static bool pack_begin(System.IntPtr obj, System.IntPtr pd, Efl.Gfx.IEntity subobj)
1801         {
1802             Eina.Log.Debug("function efl_pack_begin was called");
1803             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1804             if (ws != null)
1805             {
1806                                     bool _ret_var = default(bool);
1807                 try
1808                 {
1809                     _ret_var = ((LayoutPartInvalid)ws.Target).PackBegin(subobj);
1810                 }
1811                 catch (Exception e)
1812                 {
1813                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1814                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1815                 }
1816
1817                         return _ret_var;
1818
1819             }
1820             else
1821             {
1822                 return efl_pack_begin_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), subobj);
1823             }
1824         }
1825
1826         private static efl_pack_begin_delegate efl_pack_begin_static_delegate;
1827
1828         [return: MarshalAs(UnmanagedType.U1)]
1829         private delegate bool efl_pack_end_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))] Efl.Gfx.IEntity subobj);
1830
1831         [return: MarshalAs(UnmanagedType.U1)]
1832         public delegate bool efl_pack_end_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))] Efl.Gfx.IEntity subobj);
1833
1834         public static Efl.Eo.FunctionWrapper<efl_pack_end_api_delegate> efl_pack_end_ptr = new Efl.Eo.FunctionWrapper<efl_pack_end_api_delegate>(Module, "efl_pack_end");
1835
1836         private static bool pack_end(System.IntPtr obj, System.IntPtr pd, Efl.Gfx.IEntity subobj)
1837         {
1838             Eina.Log.Debug("function efl_pack_end was called");
1839             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1840             if (ws != null)
1841             {
1842                                     bool _ret_var = default(bool);
1843                 try
1844                 {
1845                     _ret_var = ((LayoutPartInvalid)ws.Target).PackEnd(subobj);
1846                 }
1847                 catch (Exception e)
1848                 {
1849                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1850                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1851                 }
1852
1853                         return _ret_var;
1854
1855             }
1856             else
1857             {
1858                 return efl_pack_end_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), subobj);
1859             }
1860         }
1861
1862         private static efl_pack_end_delegate efl_pack_end_static_delegate;
1863
1864         [return: MarshalAs(UnmanagedType.U1)]
1865         private delegate bool efl_pack_before_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))] Efl.Gfx.IEntity subobj, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))] Efl.Gfx.IEntity existing);
1866
1867         [return: MarshalAs(UnmanagedType.U1)]
1868         public delegate bool efl_pack_before_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))] Efl.Gfx.IEntity subobj, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))] Efl.Gfx.IEntity existing);
1869
1870         public static Efl.Eo.FunctionWrapper<efl_pack_before_api_delegate> efl_pack_before_ptr = new Efl.Eo.FunctionWrapper<efl_pack_before_api_delegate>(Module, "efl_pack_before");
1871
1872         private static bool pack_before(System.IntPtr obj, System.IntPtr pd, Efl.Gfx.IEntity subobj, Efl.Gfx.IEntity existing)
1873         {
1874             Eina.Log.Debug("function efl_pack_before was called");
1875             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1876             if (ws != null)
1877             {
1878                                                             bool _ret_var = default(bool);
1879                 try
1880                 {
1881                     _ret_var = ((LayoutPartInvalid)ws.Target).PackBefore(subobj, existing);
1882                 }
1883                 catch (Exception e)
1884                 {
1885                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1886                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1887                 }
1888
1889                                         return _ret_var;
1890
1891             }
1892             else
1893             {
1894                 return efl_pack_before_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), subobj, existing);
1895             }
1896         }
1897
1898         private static efl_pack_before_delegate efl_pack_before_static_delegate;
1899
1900         [return: MarshalAs(UnmanagedType.U1)]
1901         private delegate bool efl_pack_after_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))] Efl.Gfx.IEntity subobj, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))] Efl.Gfx.IEntity existing);
1902
1903         [return: MarshalAs(UnmanagedType.U1)]
1904         public delegate bool efl_pack_after_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))] Efl.Gfx.IEntity subobj, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))] Efl.Gfx.IEntity existing);
1905
1906         public static Efl.Eo.FunctionWrapper<efl_pack_after_api_delegate> efl_pack_after_ptr = new Efl.Eo.FunctionWrapper<efl_pack_after_api_delegate>(Module, "efl_pack_after");
1907
1908         private static bool pack_after(System.IntPtr obj, System.IntPtr pd, Efl.Gfx.IEntity subobj, Efl.Gfx.IEntity existing)
1909         {
1910             Eina.Log.Debug("function efl_pack_after was called");
1911             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1912             if (ws != null)
1913             {
1914                                                             bool _ret_var = default(bool);
1915                 try
1916                 {
1917                     _ret_var = ((LayoutPartInvalid)ws.Target).PackAfter(subobj, existing);
1918                 }
1919                 catch (Exception e)
1920                 {
1921                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1922                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1923                 }
1924
1925                                         return _ret_var;
1926
1927             }
1928             else
1929             {
1930                 return efl_pack_after_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), subobj, existing);
1931             }
1932         }
1933
1934         private static efl_pack_after_delegate efl_pack_after_static_delegate;
1935
1936         [return: MarshalAs(UnmanagedType.U1)]
1937         private delegate bool efl_pack_at_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))] Efl.Gfx.IEntity subobj,  int index);
1938
1939         [return: MarshalAs(UnmanagedType.U1)]
1940         public delegate bool efl_pack_at_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))] Efl.Gfx.IEntity subobj,  int index);
1941
1942         public static Efl.Eo.FunctionWrapper<efl_pack_at_api_delegate> efl_pack_at_ptr = new Efl.Eo.FunctionWrapper<efl_pack_at_api_delegate>(Module, "efl_pack_at");
1943
1944         private static bool pack_at(System.IntPtr obj, System.IntPtr pd, Efl.Gfx.IEntity subobj, int index)
1945         {
1946             Eina.Log.Debug("function efl_pack_at was called");
1947             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1948             if (ws != null)
1949             {
1950                                                             bool _ret_var = default(bool);
1951                 try
1952                 {
1953                     _ret_var = ((LayoutPartInvalid)ws.Target).PackAt(subobj, index);
1954                 }
1955                 catch (Exception e)
1956                 {
1957                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1958                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1959                 }
1960
1961                                         return _ret_var;
1962
1963             }
1964             else
1965             {
1966                 return efl_pack_at_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), subobj, index);
1967             }
1968         }
1969
1970         private static efl_pack_at_delegate efl_pack_at_static_delegate;
1971
1972         [return:MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))]
1973         private delegate Efl.Gfx.IEntity efl_pack_content_get_delegate(System.IntPtr obj, System.IntPtr pd,  int index);
1974
1975         [return:MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))]
1976         public delegate Efl.Gfx.IEntity efl_pack_content_get_api_delegate(System.IntPtr obj,  int index);
1977
1978         public static Efl.Eo.FunctionWrapper<efl_pack_content_get_api_delegate> efl_pack_content_get_ptr = new Efl.Eo.FunctionWrapper<efl_pack_content_get_api_delegate>(Module, "efl_pack_content_get");
1979
1980         private static Efl.Gfx.IEntity pack_content_get(System.IntPtr obj, System.IntPtr pd, int index)
1981         {
1982             Eina.Log.Debug("function efl_pack_content_get was called");
1983             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1984             if (ws != null)
1985             {
1986                                     Efl.Gfx.IEntity _ret_var = default(Efl.Gfx.IEntity);
1987                 try
1988                 {
1989                     _ret_var = ((LayoutPartInvalid)ws.Target).GetPackContent(index);
1990                 }
1991                 catch (Exception e)
1992                 {
1993                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1994                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1995                 }
1996
1997                         return _ret_var;
1998
1999             }
2000             else
2001             {
2002                 return efl_pack_content_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), index);
2003             }
2004         }
2005
2006         private static efl_pack_content_get_delegate efl_pack_content_get_static_delegate;
2007
2008
2009         private delegate int efl_pack_index_get_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))] Efl.Gfx.IEntity subobj);
2010
2011
2012         public delegate int efl_pack_index_get_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))] Efl.Gfx.IEntity subobj);
2013
2014         public static Efl.Eo.FunctionWrapper<efl_pack_index_get_api_delegate> efl_pack_index_get_ptr = new Efl.Eo.FunctionWrapper<efl_pack_index_get_api_delegate>(Module, "efl_pack_index_get");
2015
2016         private static int pack_index_get(System.IntPtr obj, System.IntPtr pd, Efl.Gfx.IEntity subobj)
2017         {
2018             Eina.Log.Debug("function efl_pack_index_get was called");
2019             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
2020             if (ws != null)
2021             {
2022                                     int _ret_var = default(int);
2023                 try
2024                 {
2025                     _ret_var = ((LayoutPartInvalid)ws.Target).GetPackIndex(subobj);
2026                 }
2027                 catch (Exception e)
2028                 {
2029                     Eina.Log.Warning($"Callback error: {e.ToString()}");
2030                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2031                 }
2032
2033                         return _ret_var;
2034
2035             }
2036             else
2037             {
2038                 return efl_pack_index_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), subobj);
2039             }
2040         }
2041
2042         private static efl_pack_index_get_delegate efl_pack_index_get_static_delegate;
2043
2044         [return:MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))]
2045         private delegate Efl.Gfx.IEntity efl_pack_unpack_at_delegate(System.IntPtr obj, System.IntPtr pd,  int index);
2046
2047         [return:MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))]
2048         public delegate Efl.Gfx.IEntity efl_pack_unpack_at_api_delegate(System.IntPtr obj,  int index);
2049
2050         public static Efl.Eo.FunctionWrapper<efl_pack_unpack_at_api_delegate> efl_pack_unpack_at_ptr = new Efl.Eo.FunctionWrapper<efl_pack_unpack_at_api_delegate>(Module, "efl_pack_unpack_at");
2051
2052         private static Efl.Gfx.IEntity pack_unpack_at(System.IntPtr obj, System.IntPtr pd, int index)
2053         {
2054             Eina.Log.Debug("function efl_pack_unpack_at was called");
2055             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
2056             if (ws != null)
2057             {
2058                                     Efl.Gfx.IEntity _ret_var = default(Efl.Gfx.IEntity);
2059                 try
2060                 {
2061                     _ret_var = ((LayoutPartInvalid)ws.Target).PackUnpackAt(index);
2062                 }
2063                 catch (Exception e)
2064                 {
2065                     Eina.Log.Warning($"Callback error: {e.ToString()}");
2066                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2067                 }
2068
2069                         return _ret_var;
2070
2071             }
2072             else
2073             {
2074                 return efl_pack_unpack_at_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), index);
2075             }
2076         }
2077
2078         private static efl_pack_unpack_at_delegate efl_pack_unpack_at_static_delegate;
2079
2080         [return: MarshalAs(UnmanagedType.U1)]
2081         private delegate bool efl_pack_table_position_get_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))] Efl.Gfx.IEntity subobj,  out int col,  out int row,  out int colspan,  out int rowspan);
2082
2083         [return: MarshalAs(UnmanagedType.U1)]
2084         public delegate bool efl_pack_table_position_get_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))] Efl.Gfx.IEntity subobj,  out int col,  out int row,  out int colspan,  out int rowspan);
2085
2086         public static Efl.Eo.FunctionWrapper<efl_pack_table_position_get_api_delegate> efl_pack_table_position_get_ptr = new Efl.Eo.FunctionWrapper<efl_pack_table_position_get_api_delegate>(Module, "efl_pack_table_position_get");
2087
2088         private static bool table_position_get(System.IntPtr obj, System.IntPtr pd, Efl.Gfx.IEntity subobj, out int col, out int row, out int colspan, out int rowspan)
2089         {
2090             Eina.Log.Debug("function efl_pack_table_position_get was called");
2091             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
2092             if (ws != null)
2093             {
2094                                                         col = default(int);        row = default(int);        colspan = default(int);        rowspan = default(int);                                                    bool _ret_var = default(bool);
2095                 try
2096                 {
2097                     _ret_var = ((LayoutPartInvalid)ws.Target).GetTablePosition(subobj, out col, out row, out colspan, out rowspan);
2098                 }
2099                 catch (Exception e)
2100                 {
2101                     Eina.Log.Warning($"Callback error: {e.ToString()}");
2102                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2103                 }
2104
2105                                                                                         return _ret_var;
2106
2107             }
2108             else
2109             {
2110                 return efl_pack_table_position_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), subobj, out col, out row, out colspan, out rowspan);
2111             }
2112         }
2113
2114         private static efl_pack_table_position_get_delegate efl_pack_table_position_get_static_delegate;
2115
2116
2117         private delegate void efl_pack_table_size_get_delegate(System.IntPtr obj, System.IntPtr pd,  out int cols,  out int rows);
2118
2119
2120         public delegate void efl_pack_table_size_get_api_delegate(System.IntPtr obj,  out int cols,  out int rows);
2121
2122         public static Efl.Eo.FunctionWrapper<efl_pack_table_size_get_api_delegate> efl_pack_table_size_get_ptr = new Efl.Eo.FunctionWrapper<efl_pack_table_size_get_api_delegate>(Module, "efl_pack_table_size_get");
2123
2124         private static void table_size_get(System.IntPtr obj, System.IntPtr pd, out int cols, out int rows)
2125         {
2126             Eina.Log.Debug("function efl_pack_table_size_get was called");
2127             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
2128             if (ws != null)
2129             {
2130                         cols = default(int);        rows = default(int);
2131                 try
2132                 {
2133                     ((LayoutPartInvalid)ws.Target).GetTableSize(out cols, out rows);
2134                 }
2135                 catch (Exception e)
2136                 {
2137                     Eina.Log.Warning($"Callback error: {e.ToString()}");
2138                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2139                 }
2140
2141
2142             }
2143             else
2144             {
2145                 efl_pack_table_size_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), out cols, out rows);
2146             }
2147         }
2148
2149         private static efl_pack_table_size_get_delegate efl_pack_table_size_get_static_delegate;
2150
2151
2152         private delegate void efl_pack_table_size_set_delegate(System.IntPtr obj, System.IntPtr pd,  int cols,  int rows);
2153
2154
2155         public delegate void efl_pack_table_size_set_api_delegate(System.IntPtr obj,  int cols,  int rows);
2156
2157         public static Efl.Eo.FunctionWrapper<efl_pack_table_size_set_api_delegate> efl_pack_table_size_set_ptr = new Efl.Eo.FunctionWrapper<efl_pack_table_size_set_api_delegate>(Module, "efl_pack_table_size_set");
2158
2159         private static void table_size_set(System.IntPtr obj, System.IntPtr pd, int cols, int rows)
2160         {
2161             Eina.Log.Debug("function efl_pack_table_size_set was called");
2162             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
2163             if (ws != null)
2164             {
2165
2166                 try
2167                 {
2168                     ((LayoutPartInvalid)ws.Target).SetTableSize(cols, rows);
2169                 }
2170                 catch (Exception e)
2171                 {
2172                     Eina.Log.Warning($"Callback error: {e.ToString()}");
2173                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2174                 }
2175
2176
2177             }
2178             else
2179             {
2180                 efl_pack_table_size_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), cols, rows);
2181             }
2182         }
2183
2184         private static efl_pack_table_size_set_delegate efl_pack_table_size_set_static_delegate;
2185
2186
2187         private delegate int efl_pack_table_columns_get_delegate(System.IntPtr obj, System.IntPtr pd);
2188
2189
2190         public delegate int efl_pack_table_columns_get_api_delegate(System.IntPtr obj);
2191
2192         public static Efl.Eo.FunctionWrapper<efl_pack_table_columns_get_api_delegate> efl_pack_table_columns_get_ptr = new Efl.Eo.FunctionWrapper<efl_pack_table_columns_get_api_delegate>(Module, "efl_pack_table_columns_get");
2193
2194         private static int table_columns_get(System.IntPtr obj, System.IntPtr pd)
2195         {
2196             Eina.Log.Debug("function efl_pack_table_columns_get was called");
2197             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
2198             if (ws != null)
2199             {
2200             int _ret_var = default(int);
2201                 try
2202                 {
2203                     _ret_var = ((LayoutPartInvalid)ws.Target).GetTableColumns();
2204                 }
2205                 catch (Exception e)
2206                 {
2207                     Eina.Log.Warning($"Callback error: {e.ToString()}");
2208                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2209                 }
2210
2211         return _ret_var;
2212
2213             }
2214             else
2215             {
2216                 return efl_pack_table_columns_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
2217             }
2218         }
2219
2220         private static efl_pack_table_columns_get_delegate efl_pack_table_columns_get_static_delegate;
2221
2222
2223         private delegate void efl_pack_table_columns_set_delegate(System.IntPtr obj, System.IntPtr pd,  int cols);
2224
2225
2226         public delegate void efl_pack_table_columns_set_api_delegate(System.IntPtr obj,  int cols);
2227
2228         public static Efl.Eo.FunctionWrapper<efl_pack_table_columns_set_api_delegate> efl_pack_table_columns_set_ptr = new Efl.Eo.FunctionWrapper<efl_pack_table_columns_set_api_delegate>(Module, "efl_pack_table_columns_set");
2229
2230         private static void table_columns_set(System.IntPtr obj, System.IntPtr pd, int cols)
2231         {
2232             Eina.Log.Debug("function efl_pack_table_columns_set was called");
2233             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
2234             if (ws != null)
2235             {
2236
2237                 try
2238                 {
2239                     ((LayoutPartInvalid)ws.Target).SetTableColumns(cols);
2240                 }
2241                 catch (Exception e)
2242                 {
2243                     Eina.Log.Warning($"Callback error: {e.ToString()}");
2244                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2245                 }
2246
2247
2248             }
2249             else
2250             {
2251                 efl_pack_table_columns_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), cols);
2252             }
2253         }
2254
2255         private static efl_pack_table_columns_set_delegate efl_pack_table_columns_set_static_delegate;
2256
2257
2258         private delegate int efl_pack_table_rows_get_delegate(System.IntPtr obj, System.IntPtr pd);
2259
2260
2261         public delegate int efl_pack_table_rows_get_api_delegate(System.IntPtr obj);
2262
2263         public static Efl.Eo.FunctionWrapper<efl_pack_table_rows_get_api_delegate> efl_pack_table_rows_get_ptr = new Efl.Eo.FunctionWrapper<efl_pack_table_rows_get_api_delegate>(Module, "efl_pack_table_rows_get");
2264
2265         private static int table_rows_get(System.IntPtr obj, System.IntPtr pd)
2266         {
2267             Eina.Log.Debug("function efl_pack_table_rows_get was called");
2268             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
2269             if (ws != null)
2270             {
2271             int _ret_var = default(int);
2272                 try
2273                 {
2274                     _ret_var = ((LayoutPartInvalid)ws.Target).GetTableRows();
2275                 }
2276                 catch (Exception e)
2277                 {
2278                     Eina.Log.Warning($"Callback error: {e.ToString()}");
2279                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2280                 }
2281
2282         return _ret_var;
2283
2284             }
2285             else
2286             {
2287                 return efl_pack_table_rows_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
2288             }
2289         }
2290
2291         private static efl_pack_table_rows_get_delegate efl_pack_table_rows_get_static_delegate;
2292
2293
2294         private delegate void efl_pack_table_rows_set_delegate(System.IntPtr obj, System.IntPtr pd,  int rows);
2295
2296
2297         public delegate void efl_pack_table_rows_set_api_delegate(System.IntPtr obj,  int rows);
2298
2299         public static Efl.Eo.FunctionWrapper<efl_pack_table_rows_set_api_delegate> efl_pack_table_rows_set_ptr = new Efl.Eo.FunctionWrapper<efl_pack_table_rows_set_api_delegate>(Module, "efl_pack_table_rows_set");
2300
2301         private static void table_rows_set(System.IntPtr obj, System.IntPtr pd, int rows)
2302         {
2303             Eina.Log.Debug("function efl_pack_table_rows_set was called");
2304             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
2305             if (ws != null)
2306             {
2307
2308                 try
2309                 {
2310                     ((LayoutPartInvalid)ws.Target).SetTableRows(rows);
2311                 }
2312                 catch (Exception e)
2313                 {
2314                     Eina.Log.Warning($"Callback error: {e.ToString()}");
2315                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2316                 }
2317
2318
2319             }
2320             else
2321             {
2322                 efl_pack_table_rows_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), rows);
2323             }
2324         }
2325
2326         private static efl_pack_table_rows_set_delegate efl_pack_table_rows_set_static_delegate;
2327
2328         [return: MarshalAs(UnmanagedType.U1)]
2329         private delegate bool efl_pack_table_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))] Efl.Gfx.IEntity subobj,  int col,  int row,  int colspan,  int rowspan);
2330
2331         [return: MarshalAs(UnmanagedType.U1)]
2332         public delegate bool efl_pack_table_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))] Efl.Gfx.IEntity subobj,  int col,  int row,  int colspan,  int rowspan);
2333
2334         public static Efl.Eo.FunctionWrapper<efl_pack_table_api_delegate> efl_pack_table_ptr = new Efl.Eo.FunctionWrapper<efl_pack_table_api_delegate>(Module, "efl_pack_table");
2335
2336         private static bool pack_table(System.IntPtr obj, System.IntPtr pd, Efl.Gfx.IEntity subobj, int col, int row, int colspan, int rowspan)
2337         {
2338             Eina.Log.Debug("function efl_pack_table was called");
2339             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
2340             if (ws != null)
2341             {
2342                                                                                                                                     bool _ret_var = default(bool);
2343                 try
2344                 {
2345                     _ret_var = ((LayoutPartInvalid)ws.Target).PackTable(subobj, col, row, colspan, rowspan);
2346                 }
2347                 catch (Exception e)
2348                 {
2349                     Eina.Log.Warning($"Callback error: {e.ToString()}");
2350                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2351                 }
2352
2353                                                                                         return _ret_var;
2354
2355             }
2356             else
2357             {
2358                 return efl_pack_table_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), subobj, col, row, colspan, rowspan);
2359             }
2360         }
2361
2362         private static efl_pack_table_delegate efl_pack_table_static_delegate;
2363
2364
2365         private delegate System.IntPtr efl_pack_table_contents_get_delegate(System.IntPtr obj, System.IntPtr pd,  int col,  int row, [MarshalAs(UnmanagedType.U1)] bool below);
2366
2367
2368         public delegate System.IntPtr efl_pack_table_contents_get_api_delegate(System.IntPtr obj,  int col,  int row, [MarshalAs(UnmanagedType.U1)] bool below);
2369
2370         public static Efl.Eo.FunctionWrapper<efl_pack_table_contents_get_api_delegate> efl_pack_table_contents_get_ptr = new Efl.Eo.FunctionWrapper<efl_pack_table_contents_get_api_delegate>(Module, "efl_pack_table_contents_get");
2371
2372         private static System.IntPtr table_contents_get(System.IntPtr obj, System.IntPtr pd, int col, int row, bool below)
2373         {
2374             Eina.Log.Debug("function efl_pack_table_contents_get was called");
2375             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
2376             if (ws != null)
2377             {
2378                                                                                     Eina.Iterator<Efl.Gfx.IEntity> _ret_var = default(Eina.Iterator<Efl.Gfx.IEntity>);
2379                 try
2380                 {
2381                     _ret_var = ((LayoutPartInvalid)ws.Target).GetTableContents(col, row, below);
2382                 }
2383                 catch (Exception e)
2384                 {
2385                     Eina.Log.Warning($"Callback error: {e.ToString()}");
2386                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2387                 }
2388
2389                                                         _ret_var.Own = false; return _ret_var.Handle;
2390
2391             }
2392             else
2393             {
2394                 return efl_pack_table_contents_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), col, row, below);
2395             }
2396         }
2397
2398         private static efl_pack_table_contents_get_delegate efl_pack_table_contents_get_static_delegate;
2399
2400         [return:MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))]
2401         private delegate Efl.Gfx.IEntity efl_pack_table_content_get_delegate(System.IntPtr obj, System.IntPtr pd,  int col,  int row);
2402
2403         [return:MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))]
2404         public delegate Efl.Gfx.IEntity efl_pack_table_content_get_api_delegate(System.IntPtr obj,  int col,  int row);
2405
2406         public static Efl.Eo.FunctionWrapper<efl_pack_table_content_get_api_delegate> efl_pack_table_content_get_ptr = new Efl.Eo.FunctionWrapper<efl_pack_table_content_get_api_delegate>(Module, "efl_pack_table_content_get");
2407
2408         private static Efl.Gfx.IEntity table_content_get(System.IntPtr obj, System.IntPtr pd, int col, int row)
2409         {
2410             Eina.Log.Debug("function efl_pack_table_content_get was called");
2411             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
2412             if (ws != null)
2413             {
2414                                                             Efl.Gfx.IEntity _ret_var = default(Efl.Gfx.IEntity);
2415                 try
2416                 {
2417                     _ret_var = ((LayoutPartInvalid)ws.Target).GetTableContent(col, row);
2418                 }
2419                 catch (Exception e)
2420                 {
2421                     Eina.Log.Warning($"Callback error: {e.ToString()}");
2422                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2423                 }
2424
2425                                         return _ret_var;
2426
2427             }
2428             else
2429             {
2430                 return efl_pack_table_content_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), col, row);
2431             }
2432         }
2433
2434         private static efl_pack_table_content_get_delegate efl_pack_table_content_get_static_delegate;
2435
2436         [return: MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))]
2437         private delegate System.String efl_text_get_delegate(System.IntPtr obj, System.IntPtr pd);
2438
2439         [return: MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))]
2440         public delegate System.String efl_text_get_api_delegate(System.IntPtr obj);
2441
2442         public static Efl.Eo.FunctionWrapper<efl_text_get_api_delegate> efl_text_get_ptr = new Efl.Eo.FunctionWrapper<efl_text_get_api_delegate>(Module, "efl_text_get");
2443
2444         private static System.String text_get(System.IntPtr obj, System.IntPtr pd)
2445         {
2446             Eina.Log.Debug("function efl_text_get was called");
2447             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
2448             if (ws != null)
2449             {
2450             System.String _ret_var = default(System.String);
2451                 try
2452                 {
2453                     _ret_var = ((LayoutPartInvalid)ws.Target).GetText();
2454                 }
2455                 catch (Exception e)
2456                 {
2457                     Eina.Log.Warning($"Callback error: {e.ToString()}");
2458                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2459                 }
2460
2461         return _ret_var;
2462
2463             }
2464             else
2465             {
2466                 return efl_text_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
2467             }
2468         }
2469
2470         private static efl_text_get_delegate efl_text_get_static_delegate;
2471
2472
2473         private delegate void efl_text_set_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))] System.String text);
2474
2475
2476         public delegate void efl_text_set_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))] System.String text);
2477
2478         public static Efl.Eo.FunctionWrapper<efl_text_set_api_delegate> efl_text_set_ptr = new Efl.Eo.FunctionWrapper<efl_text_set_api_delegate>(Module, "efl_text_set");
2479
2480         private static void text_set(System.IntPtr obj, System.IntPtr pd, System.String text)
2481         {
2482             Eina.Log.Debug("function efl_text_set was called");
2483             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
2484             if (ws != null)
2485             {
2486
2487                 try
2488                 {
2489                     ((LayoutPartInvalid)ws.Target).SetText(text);
2490                 }
2491                 catch (Exception e)
2492                 {
2493                     Eina.Log.Warning($"Callback error: {e.ToString()}");
2494                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2495                 }
2496
2497
2498             }
2499             else
2500             {
2501                 efl_text_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), text);
2502             }
2503         }
2504
2505         private static efl_text_set_delegate efl_text_set_static_delegate;
2506
2507
2508         private delegate Efl.TextCursorCursor efl_text_cursor_get_delegate(System.IntPtr obj, System.IntPtr pd,  Efl.TextCursorGetType get_type);
2509
2510
2511         public delegate Efl.TextCursorCursor efl_text_cursor_get_api_delegate(System.IntPtr obj,  Efl.TextCursorGetType get_type);
2512
2513         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");
2514
2515         private static Efl.TextCursorCursor text_cursor_get(System.IntPtr obj, System.IntPtr pd, Efl.TextCursorGetType get_type)
2516         {
2517             Eina.Log.Debug("function efl_text_cursor_get was called");
2518             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
2519             if (ws != null)
2520             {
2521                                     Efl.TextCursorCursor _ret_var = default(Efl.TextCursorCursor);
2522                 try
2523                 {
2524                     _ret_var = ((LayoutPartInvalid)ws.Target).GetTextCursor(get_type);
2525                 }
2526                 catch (Exception e)
2527                 {
2528                     Eina.Log.Warning($"Callback error: {e.ToString()}");
2529                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2530                 }
2531
2532                         return _ret_var;
2533
2534             }
2535             else
2536             {
2537                 return efl_text_cursor_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), get_type);
2538             }
2539         }
2540
2541         private static efl_text_cursor_get_delegate efl_text_cursor_get_static_delegate;
2542
2543
2544         private delegate int efl_text_cursor_position_get_delegate(System.IntPtr obj, System.IntPtr pd,  Efl.TextCursorCursor cur);
2545
2546
2547         public delegate int efl_text_cursor_position_get_api_delegate(System.IntPtr obj,  Efl.TextCursorCursor cur);
2548
2549         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");
2550
2551         private static int cursor_position_get(System.IntPtr obj, System.IntPtr pd, Efl.TextCursorCursor cur)
2552         {
2553             Eina.Log.Debug("function efl_text_cursor_position_get was called");
2554             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
2555             if (ws != null)
2556             {
2557                                     int _ret_var = default(int);
2558                 try
2559                 {
2560                     _ret_var = ((LayoutPartInvalid)ws.Target).GetCursorPosition(cur);
2561                 }
2562                 catch (Exception e)
2563                 {
2564                     Eina.Log.Warning($"Callback error: {e.ToString()}");
2565                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2566                 }
2567
2568                         return _ret_var;
2569
2570             }
2571             else
2572             {
2573                 return efl_text_cursor_position_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), cur);
2574             }
2575         }
2576
2577         private static efl_text_cursor_position_get_delegate efl_text_cursor_position_get_static_delegate;
2578
2579
2580         private delegate void efl_text_cursor_position_set_delegate(System.IntPtr obj, System.IntPtr pd,  Efl.TextCursorCursor cur,  int position);
2581
2582
2583         public delegate void efl_text_cursor_position_set_api_delegate(System.IntPtr obj,  Efl.TextCursorCursor cur,  int position);
2584
2585         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");
2586
2587         private static void cursor_position_set(System.IntPtr obj, System.IntPtr pd, Efl.TextCursorCursor cur, int position)
2588         {
2589             Eina.Log.Debug("function efl_text_cursor_position_set was called");
2590             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
2591             if (ws != null)
2592             {
2593
2594                 try
2595                 {
2596                     ((LayoutPartInvalid)ws.Target).SetCursorPosition(cur, position);
2597                 }
2598                 catch (Exception e)
2599                 {
2600                     Eina.Log.Warning($"Callback error: {e.ToString()}");
2601                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2602                 }
2603
2604
2605             }
2606             else
2607             {
2608                 efl_text_cursor_position_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), cur, position);
2609             }
2610         }
2611
2612         private static efl_text_cursor_position_set_delegate efl_text_cursor_position_set_static_delegate;
2613
2614
2615         private delegate Eina.Unicode efl_text_cursor_content_get_delegate(System.IntPtr obj, System.IntPtr pd,  Efl.TextCursorCursor cur);
2616
2617
2618         public delegate Eina.Unicode efl_text_cursor_content_get_api_delegate(System.IntPtr obj,  Efl.TextCursorCursor cur);
2619
2620         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");
2621
2622         private static Eina.Unicode cursor_content_get(System.IntPtr obj, System.IntPtr pd, Efl.TextCursorCursor cur)
2623         {
2624             Eina.Log.Debug("function efl_text_cursor_content_get was called");
2625             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
2626             if (ws != null)
2627             {
2628                                     Eina.Unicode _ret_var = default(Eina.Unicode);
2629                 try
2630                 {
2631                     _ret_var = ((LayoutPartInvalid)ws.Target).GetCursorContent(cur);
2632                 }
2633                 catch (Exception e)
2634                 {
2635                     Eina.Log.Warning($"Callback error: {e.ToString()}");
2636                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2637                 }
2638
2639                         return _ret_var;
2640
2641             }
2642             else
2643             {
2644                 return efl_text_cursor_content_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), cur);
2645             }
2646         }
2647
2648         private static efl_text_cursor_content_get_delegate efl_text_cursor_content_get_static_delegate;
2649
2650         [return: MarshalAs(UnmanagedType.U1)]
2651         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);
2652
2653         [return: MarshalAs(UnmanagedType.U1)]
2654         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);
2655
2656         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");
2657
2658         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)
2659         {
2660             Eina.Log.Debug("function efl_text_cursor_geometry_get was called");
2661             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
2662             if (ws != null)
2663             {
2664                                                                                                         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);
2665                 try
2666                 {
2667                     _ret_var = ((LayoutPartInvalid)ws.Target).GetCursorGeometry(cur, ctype, out cx, out cy, out cw, out ch, out cx2, out cy2, out cw2, out ch2);
2668                 }
2669                 catch (Exception e)
2670                 {
2671                     Eina.Log.Warning($"Callback error: {e.ToString()}");
2672                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2673                 }
2674
2675                                                                                                                                                                         return _ret_var;
2676
2677             }
2678             else
2679             {
2680                 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);
2681             }
2682         }
2683
2684         private static efl_text_cursor_geometry_get_delegate efl_text_cursor_geometry_get_static_delegate;
2685
2686
2687         private delegate Efl.TextCursorCursor efl_text_cursor_new_delegate(System.IntPtr obj, System.IntPtr pd);
2688
2689
2690         public delegate Efl.TextCursorCursor efl_text_cursor_new_api_delegate(System.IntPtr obj);
2691
2692         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");
2693
2694         private static Efl.TextCursorCursor cursor_new(System.IntPtr obj, System.IntPtr pd)
2695         {
2696             Eina.Log.Debug("function efl_text_cursor_new was called");
2697             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
2698             if (ws != null)
2699             {
2700             Efl.TextCursorCursor _ret_var = default(Efl.TextCursorCursor);
2701                 try
2702                 {
2703                     _ret_var = ((LayoutPartInvalid)ws.Target).NewCursor();
2704                 }
2705                 catch (Exception e)
2706                 {
2707                     Eina.Log.Warning($"Callback error: {e.ToString()}");
2708                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2709                 }
2710
2711         return _ret_var;
2712
2713             }
2714             else
2715             {
2716                 return efl_text_cursor_new_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
2717             }
2718         }
2719
2720         private static efl_text_cursor_new_delegate efl_text_cursor_new_static_delegate;
2721
2722
2723         private delegate void efl_text_cursor_free_delegate(System.IntPtr obj, System.IntPtr pd,  Efl.TextCursorCursor cur);
2724
2725
2726         public delegate void efl_text_cursor_free_api_delegate(System.IntPtr obj,  Efl.TextCursorCursor cur);
2727
2728         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");
2729
2730         private static void cursor_free(System.IntPtr obj, System.IntPtr pd, Efl.TextCursorCursor cur)
2731         {
2732             Eina.Log.Debug("function efl_text_cursor_free was called");
2733             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
2734             if (ws != null)
2735             {
2736
2737                 try
2738                 {
2739                     ((LayoutPartInvalid)ws.Target).CursorFree(cur);
2740                 }
2741                 catch (Exception e)
2742                 {
2743                     Eina.Log.Warning($"Callback error: {e.ToString()}");
2744                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2745                 }
2746
2747
2748             }
2749             else
2750             {
2751                 efl_text_cursor_free_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), cur);
2752             }
2753         }
2754
2755         private static efl_text_cursor_free_delegate efl_text_cursor_free_static_delegate;
2756
2757         [return: MarshalAs(UnmanagedType.U1)]
2758         private delegate bool efl_text_cursor_equal_delegate(System.IntPtr obj, System.IntPtr pd,  Efl.TextCursorCursor cur1,  Efl.TextCursorCursor cur2);
2759
2760         [return: MarshalAs(UnmanagedType.U1)]
2761         public delegate bool efl_text_cursor_equal_api_delegate(System.IntPtr obj,  Efl.TextCursorCursor cur1,  Efl.TextCursorCursor cur2);
2762
2763         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");
2764
2765         private static bool cursor_equal(System.IntPtr obj, System.IntPtr pd, Efl.TextCursorCursor cur1, Efl.TextCursorCursor cur2)
2766         {
2767             Eina.Log.Debug("function efl_text_cursor_equal was called");
2768             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
2769             if (ws != null)
2770             {
2771                                                             bool _ret_var = default(bool);
2772                 try
2773                 {
2774                     _ret_var = ((LayoutPartInvalid)ws.Target).CursorEqual(cur1, cur2);
2775                 }
2776                 catch (Exception e)
2777                 {
2778                     Eina.Log.Warning($"Callback error: {e.ToString()}");
2779                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2780                 }
2781
2782                                         return _ret_var;
2783
2784             }
2785             else
2786             {
2787                 return efl_text_cursor_equal_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), cur1, cur2);
2788             }
2789         }
2790
2791         private static efl_text_cursor_equal_delegate efl_text_cursor_equal_static_delegate;
2792
2793
2794         private delegate int efl_text_cursor_compare_delegate(System.IntPtr obj, System.IntPtr pd,  Efl.TextCursorCursor cur1,  Efl.TextCursorCursor cur2);
2795
2796
2797         public delegate int efl_text_cursor_compare_api_delegate(System.IntPtr obj,  Efl.TextCursorCursor cur1,  Efl.TextCursorCursor cur2);
2798
2799         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");
2800
2801         private static int cursor_compare(System.IntPtr obj, System.IntPtr pd, Efl.TextCursorCursor cur1, Efl.TextCursorCursor cur2)
2802         {
2803             Eina.Log.Debug("function efl_text_cursor_compare was called");
2804             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
2805             if (ws != null)
2806             {
2807                                                             int _ret_var = default(int);
2808                 try
2809                 {
2810                     _ret_var = ((LayoutPartInvalid)ws.Target).CursorCompare(cur1, cur2);
2811                 }
2812                 catch (Exception e)
2813                 {
2814                     Eina.Log.Warning($"Callback error: {e.ToString()}");
2815                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2816                 }
2817
2818                                         return _ret_var;
2819
2820             }
2821             else
2822             {
2823                 return efl_text_cursor_compare_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), cur1, cur2);
2824             }
2825         }
2826
2827         private static efl_text_cursor_compare_delegate efl_text_cursor_compare_static_delegate;
2828
2829
2830         private delegate void efl_text_cursor_copy_delegate(System.IntPtr obj, System.IntPtr pd,  Efl.TextCursorCursor dst,  Efl.TextCursorCursor src);
2831
2832
2833         public delegate void efl_text_cursor_copy_api_delegate(System.IntPtr obj,  Efl.TextCursorCursor dst,  Efl.TextCursorCursor src);
2834
2835         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");
2836
2837         private static void cursor_copy(System.IntPtr obj, System.IntPtr pd, Efl.TextCursorCursor dst, Efl.TextCursorCursor src)
2838         {
2839             Eina.Log.Debug("function efl_text_cursor_copy was called");
2840             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
2841             if (ws != null)
2842             {
2843
2844                 try
2845                 {
2846                     ((LayoutPartInvalid)ws.Target).CursorCopy(dst, src);
2847                 }
2848                 catch (Exception e)
2849                 {
2850                     Eina.Log.Warning($"Callback error: {e.ToString()}");
2851                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2852                 }
2853
2854
2855             }
2856             else
2857             {
2858                 efl_text_cursor_copy_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), dst, src);
2859             }
2860         }
2861
2862         private static efl_text_cursor_copy_delegate efl_text_cursor_copy_static_delegate;
2863
2864
2865         private delegate void efl_text_cursor_char_next_delegate(System.IntPtr obj, System.IntPtr pd,  Efl.TextCursorCursor cur);
2866
2867
2868         public delegate void efl_text_cursor_char_next_api_delegate(System.IntPtr obj,  Efl.TextCursorCursor cur);
2869
2870         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");
2871
2872         private static void cursor_char_next(System.IntPtr obj, System.IntPtr pd, Efl.TextCursorCursor cur)
2873         {
2874             Eina.Log.Debug("function efl_text_cursor_char_next was called");
2875             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
2876             if (ws != null)
2877             {
2878
2879                 try
2880                 {
2881                     ((LayoutPartInvalid)ws.Target).CursorCharNext(cur);
2882                 }
2883                 catch (Exception e)
2884                 {
2885                     Eina.Log.Warning($"Callback error: {e.ToString()}");
2886                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2887                 }
2888
2889
2890             }
2891             else
2892             {
2893                 efl_text_cursor_char_next_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), cur);
2894             }
2895         }
2896
2897         private static efl_text_cursor_char_next_delegate efl_text_cursor_char_next_static_delegate;
2898
2899
2900         private delegate void efl_text_cursor_char_prev_delegate(System.IntPtr obj, System.IntPtr pd,  Efl.TextCursorCursor cur);
2901
2902
2903         public delegate void efl_text_cursor_char_prev_api_delegate(System.IntPtr obj,  Efl.TextCursorCursor cur);
2904
2905         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");
2906
2907         private static void cursor_char_prev(System.IntPtr obj, System.IntPtr pd, Efl.TextCursorCursor cur)
2908         {
2909             Eina.Log.Debug("function efl_text_cursor_char_prev was called");
2910             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
2911             if (ws != null)
2912             {
2913
2914                 try
2915                 {
2916                     ((LayoutPartInvalid)ws.Target).CursorCharPrev(cur);
2917                 }
2918                 catch (Exception e)
2919                 {
2920                     Eina.Log.Warning($"Callback error: {e.ToString()}");
2921                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2922                 }
2923
2924
2925             }
2926             else
2927             {
2928                 efl_text_cursor_char_prev_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), cur);
2929             }
2930         }
2931
2932         private static efl_text_cursor_char_prev_delegate efl_text_cursor_char_prev_static_delegate;
2933
2934
2935         private delegate void efl_text_cursor_cluster_next_delegate(System.IntPtr obj, System.IntPtr pd,  Efl.TextCursorCursor cur);
2936
2937
2938         public delegate void efl_text_cursor_cluster_next_api_delegate(System.IntPtr obj,  Efl.TextCursorCursor cur);
2939
2940         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");
2941
2942         private static void cursor_cluster_next(System.IntPtr obj, System.IntPtr pd, Efl.TextCursorCursor cur)
2943         {
2944             Eina.Log.Debug("function efl_text_cursor_cluster_next was called");
2945             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
2946             if (ws != null)
2947             {
2948
2949                 try
2950                 {
2951                     ((LayoutPartInvalid)ws.Target).CursorClusterNext(cur);
2952                 }
2953                 catch (Exception e)
2954                 {
2955                     Eina.Log.Warning($"Callback error: {e.ToString()}");
2956                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2957                 }
2958
2959
2960             }
2961             else
2962             {
2963                 efl_text_cursor_cluster_next_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), cur);
2964             }
2965         }
2966
2967         private static efl_text_cursor_cluster_next_delegate efl_text_cursor_cluster_next_static_delegate;
2968
2969
2970         private delegate void efl_text_cursor_cluster_prev_delegate(System.IntPtr obj, System.IntPtr pd,  Efl.TextCursorCursor cur);
2971
2972
2973         public delegate void efl_text_cursor_cluster_prev_api_delegate(System.IntPtr obj,  Efl.TextCursorCursor cur);
2974
2975         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");
2976
2977         private static void cursor_cluster_prev(System.IntPtr obj, System.IntPtr pd, Efl.TextCursorCursor cur)
2978         {
2979             Eina.Log.Debug("function efl_text_cursor_cluster_prev was called");
2980             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
2981             if (ws != null)
2982             {
2983
2984                 try
2985                 {
2986                     ((LayoutPartInvalid)ws.Target).CursorClusterPrev(cur);
2987                 }
2988                 catch (Exception e)
2989                 {
2990                     Eina.Log.Warning($"Callback error: {e.ToString()}");
2991                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2992                 }
2993
2994
2995             }
2996             else
2997             {
2998                 efl_text_cursor_cluster_prev_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), cur);
2999             }
3000         }
3001
3002         private static efl_text_cursor_cluster_prev_delegate efl_text_cursor_cluster_prev_static_delegate;
3003
3004
3005         private delegate void efl_text_cursor_paragraph_char_first_delegate(System.IntPtr obj, System.IntPtr pd,  Efl.TextCursorCursor cur);
3006
3007
3008         public delegate void efl_text_cursor_paragraph_char_first_api_delegate(System.IntPtr obj,  Efl.TextCursorCursor cur);
3009
3010         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");
3011
3012         private static void cursor_paragraph_char_first(System.IntPtr obj, System.IntPtr pd, Efl.TextCursorCursor cur)
3013         {
3014             Eina.Log.Debug("function efl_text_cursor_paragraph_char_first was called");
3015             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
3016             if (ws != null)
3017             {
3018
3019                 try
3020                 {
3021                     ((LayoutPartInvalid)ws.Target).CursorParagraphCharFirst(cur);
3022                 }
3023                 catch (Exception e)
3024                 {
3025                     Eina.Log.Warning($"Callback error: {e.ToString()}");
3026                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
3027                 }
3028
3029
3030             }
3031             else
3032             {
3033                 efl_text_cursor_paragraph_char_first_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), cur);
3034             }
3035         }
3036
3037         private static efl_text_cursor_paragraph_char_first_delegate efl_text_cursor_paragraph_char_first_static_delegate;
3038
3039
3040         private delegate void efl_text_cursor_paragraph_char_last_delegate(System.IntPtr obj, System.IntPtr pd,  Efl.TextCursorCursor cur);
3041
3042
3043         public delegate void efl_text_cursor_paragraph_char_last_api_delegate(System.IntPtr obj,  Efl.TextCursorCursor cur);
3044
3045         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");
3046
3047         private static void cursor_paragraph_char_last(System.IntPtr obj, System.IntPtr pd, Efl.TextCursorCursor cur)
3048         {
3049             Eina.Log.Debug("function efl_text_cursor_paragraph_char_last was called");
3050             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
3051             if (ws != null)
3052             {
3053
3054                 try
3055                 {
3056                     ((LayoutPartInvalid)ws.Target).CursorParagraphCharLast(cur);
3057                 }
3058                 catch (Exception e)
3059                 {
3060                     Eina.Log.Warning($"Callback error: {e.ToString()}");
3061                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
3062                 }
3063
3064
3065             }
3066             else
3067             {
3068                 efl_text_cursor_paragraph_char_last_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), cur);
3069             }
3070         }
3071
3072         private static efl_text_cursor_paragraph_char_last_delegate efl_text_cursor_paragraph_char_last_static_delegate;
3073
3074
3075         private delegate void efl_text_cursor_word_start_delegate(System.IntPtr obj, System.IntPtr pd,  Efl.TextCursorCursor cur);
3076
3077
3078         public delegate void efl_text_cursor_word_start_api_delegate(System.IntPtr obj,  Efl.TextCursorCursor cur);
3079
3080         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");
3081
3082         private static void cursor_word_start(System.IntPtr obj, System.IntPtr pd, Efl.TextCursorCursor cur)
3083         {
3084             Eina.Log.Debug("function efl_text_cursor_word_start was called");
3085             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
3086             if (ws != null)
3087             {
3088
3089                 try
3090                 {
3091                     ((LayoutPartInvalid)ws.Target).CursorWordStart(cur);
3092                 }
3093                 catch (Exception e)
3094                 {
3095                     Eina.Log.Warning($"Callback error: {e.ToString()}");
3096                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
3097                 }
3098
3099
3100             }
3101             else
3102             {
3103                 efl_text_cursor_word_start_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), cur);
3104             }
3105         }
3106
3107         private static efl_text_cursor_word_start_delegate efl_text_cursor_word_start_static_delegate;
3108
3109
3110         private delegate void efl_text_cursor_word_end_delegate(System.IntPtr obj, System.IntPtr pd,  Efl.TextCursorCursor cur);
3111
3112
3113         public delegate void efl_text_cursor_word_end_api_delegate(System.IntPtr obj,  Efl.TextCursorCursor cur);
3114
3115         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");
3116
3117         private static void cursor_word_end(System.IntPtr obj, System.IntPtr pd, Efl.TextCursorCursor cur)
3118         {
3119             Eina.Log.Debug("function efl_text_cursor_word_end was called");
3120             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
3121             if (ws != null)
3122             {
3123
3124                 try
3125                 {
3126                     ((LayoutPartInvalid)ws.Target).CursorWordEnd(cur);
3127                 }
3128                 catch (Exception e)
3129                 {
3130                     Eina.Log.Warning($"Callback error: {e.ToString()}");
3131                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
3132                 }
3133
3134
3135             }
3136             else
3137             {
3138                 efl_text_cursor_word_end_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), cur);
3139             }
3140         }
3141
3142         private static efl_text_cursor_word_end_delegate efl_text_cursor_word_end_static_delegate;
3143
3144
3145         private delegate void efl_text_cursor_line_char_first_delegate(System.IntPtr obj, System.IntPtr pd,  Efl.TextCursorCursor cur);
3146
3147
3148         public delegate void efl_text_cursor_line_char_first_api_delegate(System.IntPtr obj,  Efl.TextCursorCursor cur);
3149
3150         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");
3151
3152         private static void cursor_line_char_first(System.IntPtr obj, System.IntPtr pd, Efl.TextCursorCursor cur)
3153         {
3154             Eina.Log.Debug("function efl_text_cursor_line_char_first was called");
3155             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
3156             if (ws != null)
3157             {
3158
3159                 try
3160                 {
3161                     ((LayoutPartInvalid)ws.Target).CursorLineCharFirst(cur);
3162                 }
3163                 catch (Exception e)
3164                 {
3165                     Eina.Log.Warning($"Callback error: {e.ToString()}");
3166                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
3167                 }
3168
3169
3170             }
3171             else
3172             {
3173                 efl_text_cursor_line_char_first_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), cur);
3174             }
3175         }
3176
3177         private static efl_text_cursor_line_char_first_delegate efl_text_cursor_line_char_first_static_delegate;
3178
3179
3180         private delegate void efl_text_cursor_line_char_last_delegate(System.IntPtr obj, System.IntPtr pd,  Efl.TextCursorCursor cur);
3181
3182
3183         public delegate void efl_text_cursor_line_char_last_api_delegate(System.IntPtr obj,  Efl.TextCursorCursor cur);
3184
3185         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");
3186
3187         private static void cursor_line_char_last(System.IntPtr obj, System.IntPtr pd, Efl.TextCursorCursor cur)
3188         {
3189             Eina.Log.Debug("function efl_text_cursor_line_char_last was called");
3190             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
3191             if (ws != null)
3192             {
3193
3194                 try
3195                 {
3196                     ((LayoutPartInvalid)ws.Target).CursorLineCharLast(cur);
3197                 }
3198                 catch (Exception e)
3199                 {
3200                     Eina.Log.Warning($"Callback error: {e.ToString()}");
3201                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
3202                 }
3203
3204
3205             }
3206             else
3207             {
3208                 efl_text_cursor_line_char_last_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), cur);
3209             }
3210         }
3211
3212         private static efl_text_cursor_line_char_last_delegate efl_text_cursor_line_char_last_static_delegate;
3213
3214
3215         private delegate void efl_text_cursor_paragraph_first_delegate(System.IntPtr obj, System.IntPtr pd,  Efl.TextCursorCursor cur);
3216
3217
3218         public delegate void efl_text_cursor_paragraph_first_api_delegate(System.IntPtr obj,  Efl.TextCursorCursor cur);
3219
3220         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");
3221
3222         private static void cursor_paragraph_first(System.IntPtr obj, System.IntPtr pd, Efl.TextCursorCursor cur)
3223         {
3224             Eina.Log.Debug("function efl_text_cursor_paragraph_first was called");
3225             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
3226             if (ws != null)
3227             {
3228
3229                 try
3230                 {
3231                     ((LayoutPartInvalid)ws.Target).CursorParagraphFirst(cur);
3232                 }
3233                 catch (Exception e)
3234                 {
3235                     Eina.Log.Warning($"Callback error: {e.ToString()}");
3236                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
3237                 }
3238
3239
3240             }
3241             else
3242             {
3243                 efl_text_cursor_paragraph_first_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), cur);
3244             }
3245         }
3246
3247         private static efl_text_cursor_paragraph_first_delegate efl_text_cursor_paragraph_first_static_delegate;
3248
3249
3250         private delegate void efl_text_cursor_paragraph_last_delegate(System.IntPtr obj, System.IntPtr pd,  Efl.TextCursorCursor cur);
3251
3252
3253         public delegate void efl_text_cursor_paragraph_last_api_delegate(System.IntPtr obj,  Efl.TextCursorCursor cur);
3254
3255         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");
3256
3257         private static void cursor_paragraph_last(System.IntPtr obj, System.IntPtr pd, Efl.TextCursorCursor cur)
3258         {
3259             Eina.Log.Debug("function efl_text_cursor_paragraph_last was called");
3260             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
3261             if (ws != null)
3262             {
3263
3264                 try
3265                 {
3266                     ((LayoutPartInvalid)ws.Target).CursorParagraphLast(cur);
3267                 }
3268                 catch (Exception e)
3269                 {
3270                     Eina.Log.Warning($"Callback error: {e.ToString()}");
3271                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
3272                 }
3273
3274
3275             }
3276             else
3277             {
3278                 efl_text_cursor_paragraph_last_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), cur);
3279             }
3280         }
3281
3282         private static efl_text_cursor_paragraph_last_delegate efl_text_cursor_paragraph_last_static_delegate;
3283
3284
3285         private delegate void efl_text_cursor_paragraph_next_delegate(System.IntPtr obj, System.IntPtr pd,  Efl.TextCursorCursor cur);
3286
3287
3288         public delegate void efl_text_cursor_paragraph_next_api_delegate(System.IntPtr obj,  Efl.TextCursorCursor cur);
3289
3290         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");
3291
3292         private static void cursor_paragraph_next(System.IntPtr obj, System.IntPtr pd, Efl.TextCursorCursor cur)
3293         {
3294             Eina.Log.Debug("function efl_text_cursor_paragraph_next was called");
3295             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
3296             if (ws != null)
3297             {
3298
3299                 try
3300                 {
3301                     ((LayoutPartInvalid)ws.Target).CursorParagraphNext(cur);
3302                 }
3303                 catch (Exception e)
3304                 {
3305                     Eina.Log.Warning($"Callback error: {e.ToString()}");
3306                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
3307                 }
3308
3309
3310             }
3311             else
3312             {
3313                 efl_text_cursor_paragraph_next_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), cur);
3314             }
3315         }
3316
3317         private static efl_text_cursor_paragraph_next_delegate efl_text_cursor_paragraph_next_static_delegate;
3318
3319
3320         private delegate void efl_text_cursor_paragraph_prev_delegate(System.IntPtr obj, System.IntPtr pd,  Efl.TextCursorCursor cur);
3321
3322
3323         public delegate void efl_text_cursor_paragraph_prev_api_delegate(System.IntPtr obj,  Efl.TextCursorCursor cur);
3324
3325         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");
3326
3327         private static void cursor_paragraph_prev(System.IntPtr obj, System.IntPtr pd, Efl.TextCursorCursor cur)
3328         {
3329             Eina.Log.Debug("function efl_text_cursor_paragraph_prev was called");
3330             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
3331             if (ws != null)
3332             {
3333
3334                 try
3335                 {
3336                     ((LayoutPartInvalid)ws.Target).CursorParagraphPrev(cur);
3337                 }
3338                 catch (Exception e)
3339                 {
3340                     Eina.Log.Warning($"Callback error: {e.ToString()}");
3341                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
3342                 }
3343
3344
3345             }
3346             else
3347             {
3348                 efl_text_cursor_paragraph_prev_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), cur);
3349             }
3350         }
3351
3352         private static efl_text_cursor_paragraph_prev_delegate efl_text_cursor_paragraph_prev_static_delegate;
3353
3354
3355         private delegate void efl_text_cursor_line_jump_by_delegate(System.IntPtr obj, System.IntPtr pd,  Efl.TextCursorCursor cur,  int by);
3356
3357
3358         public delegate void efl_text_cursor_line_jump_by_api_delegate(System.IntPtr obj,  Efl.TextCursorCursor cur,  int by);
3359
3360         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");
3361
3362         private static void cursor_line_jump_by(System.IntPtr obj, System.IntPtr pd, Efl.TextCursorCursor cur, int by)
3363         {
3364             Eina.Log.Debug("function efl_text_cursor_line_jump_by was called");
3365             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
3366             if (ws != null)
3367             {
3368
3369                 try
3370                 {
3371                     ((LayoutPartInvalid)ws.Target).CursorLineJumpBy(cur, by);
3372                 }
3373                 catch (Exception e)
3374                 {
3375                     Eina.Log.Warning($"Callback error: {e.ToString()}");
3376                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
3377                 }
3378
3379
3380             }
3381             else
3382             {
3383                 efl_text_cursor_line_jump_by_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), cur, by);
3384             }
3385         }
3386
3387         private static efl_text_cursor_line_jump_by_delegate efl_text_cursor_line_jump_by_static_delegate;
3388
3389
3390         private delegate void efl_text_cursor_coord_set_delegate(System.IntPtr obj, System.IntPtr pd,  Efl.TextCursorCursor cur,  int x,  int y);
3391
3392
3393         public delegate void efl_text_cursor_coord_set_api_delegate(System.IntPtr obj,  Efl.TextCursorCursor cur,  int x,  int y);
3394
3395         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");
3396
3397         private static void cursor_coord_set(System.IntPtr obj, System.IntPtr pd, Efl.TextCursorCursor cur, int x, int y)
3398         {
3399             Eina.Log.Debug("function efl_text_cursor_coord_set was called");
3400             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
3401             if (ws != null)
3402             {
3403
3404                 try
3405                 {
3406                     ((LayoutPartInvalid)ws.Target).SetCursorCoord(cur, x, y);
3407                 }
3408                 catch (Exception e)
3409                 {
3410                     Eina.Log.Warning($"Callback error: {e.ToString()}");
3411                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
3412                 }
3413
3414
3415             }
3416             else
3417             {
3418                 efl_text_cursor_coord_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), cur, x, y);
3419             }
3420         }
3421
3422         private static efl_text_cursor_coord_set_delegate efl_text_cursor_coord_set_static_delegate;
3423
3424
3425         private delegate void efl_text_cursor_cluster_coord_set_delegate(System.IntPtr obj, System.IntPtr pd,  Efl.TextCursorCursor cur,  int x,  int y);
3426
3427
3428         public delegate void efl_text_cursor_cluster_coord_set_api_delegate(System.IntPtr obj,  Efl.TextCursorCursor cur,  int x,  int y);
3429
3430         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");
3431
3432         private static void cursor_cluster_coord_set(System.IntPtr obj, System.IntPtr pd, Efl.TextCursorCursor cur, int x, int y)
3433         {
3434             Eina.Log.Debug("function efl_text_cursor_cluster_coord_set was called");
3435             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
3436             if (ws != null)
3437             {
3438
3439                 try
3440                 {
3441                     ((LayoutPartInvalid)ws.Target).SetCursorClusterCoord(cur, x, y);
3442                 }
3443                 catch (Exception e)
3444                 {
3445                     Eina.Log.Warning($"Callback error: {e.ToString()}");
3446                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
3447                 }
3448
3449
3450             }
3451             else
3452             {
3453                 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);
3454             }
3455         }
3456
3457         private static efl_text_cursor_cluster_coord_set_delegate efl_text_cursor_cluster_coord_set_static_delegate;
3458
3459
3460         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);
3461
3462
3463         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);
3464
3465         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");
3466
3467         private static int cursor_text_insert(System.IntPtr obj, System.IntPtr pd, Efl.TextCursorCursor cur, System.String text)
3468         {
3469             Eina.Log.Debug("function efl_text_cursor_text_insert was called");
3470             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
3471             if (ws != null)
3472             {
3473                                                             int _ret_var = default(int);
3474                 try
3475                 {
3476                     _ret_var = ((LayoutPartInvalid)ws.Target).CursorTextInsert(cur, text);
3477                 }
3478                 catch (Exception e)
3479                 {
3480                     Eina.Log.Warning($"Callback error: {e.ToString()}");
3481                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
3482                 }
3483
3484                                         return _ret_var;
3485
3486             }
3487             else
3488             {
3489                 return efl_text_cursor_text_insert_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), cur, text);
3490             }
3491         }
3492
3493         private static efl_text_cursor_text_insert_delegate efl_text_cursor_text_insert_static_delegate;
3494
3495
3496         private delegate void efl_text_cursor_char_delete_delegate(System.IntPtr obj, System.IntPtr pd,  Efl.TextCursorCursor cur);
3497
3498
3499         public delegate void efl_text_cursor_char_delete_api_delegate(System.IntPtr obj,  Efl.TextCursorCursor cur);
3500
3501         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");
3502
3503         private static void cursor_char_delete(System.IntPtr obj, System.IntPtr pd, Efl.TextCursorCursor cur)
3504         {
3505             Eina.Log.Debug("function efl_text_cursor_char_delete was called");
3506             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
3507             if (ws != null)
3508             {
3509
3510                 try
3511                 {
3512                     ((LayoutPartInvalid)ws.Target).CursorCharDelete(cur);
3513                 }
3514                 catch (Exception e)
3515                 {
3516                     Eina.Log.Warning($"Callback error: {e.ToString()}");
3517                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
3518                 }
3519
3520
3521             }
3522             else
3523             {
3524                 efl_text_cursor_char_delete_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), cur);
3525             }
3526         }
3527
3528         private static efl_text_cursor_char_delete_delegate efl_text_cursor_char_delete_static_delegate;
3529
3530         [return: MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))]
3531         private delegate System.String efl_text_markup_get_delegate(System.IntPtr obj, System.IntPtr pd);
3532
3533         [return: MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))]
3534         public delegate System.String efl_text_markup_get_api_delegate(System.IntPtr obj);
3535
3536         public static Efl.Eo.FunctionWrapper<efl_text_markup_get_api_delegate> efl_text_markup_get_ptr = new Efl.Eo.FunctionWrapper<efl_text_markup_get_api_delegate>(Module, "efl_text_markup_get");
3537
3538         private static System.String markup_get(System.IntPtr obj, System.IntPtr pd)
3539         {
3540             Eina.Log.Debug("function efl_text_markup_get was called");
3541             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
3542             if (ws != null)
3543             {
3544             System.String _ret_var = default(System.String);
3545                 try
3546                 {
3547                     _ret_var = ((LayoutPartInvalid)ws.Target).GetMarkup();
3548                 }
3549                 catch (Exception e)
3550                 {
3551                     Eina.Log.Warning($"Callback error: {e.ToString()}");
3552                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
3553                 }
3554
3555         return _ret_var;
3556
3557             }
3558             else
3559             {
3560                 return efl_text_markup_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
3561             }
3562         }
3563
3564         private static efl_text_markup_get_delegate efl_text_markup_get_static_delegate;
3565
3566
3567         private delegate void efl_text_markup_set_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))] System.String markup);
3568
3569
3570         public delegate void efl_text_markup_set_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))] System.String markup);
3571
3572         public static Efl.Eo.FunctionWrapper<efl_text_markup_set_api_delegate> efl_text_markup_set_ptr = new Efl.Eo.FunctionWrapper<efl_text_markup_set_api_delegate>(Module, "efl_text_markup_set");
3573
3574         private static void markup_set(System.IntPtr obj, System.IntPtr pd, System.String markup)
3575         {
3576             Eina.Log.Debug("function efl_text_markup_set was called");
3577             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
3578             if (ws != null)
3579             {
3580
3581                 try
3582                 {
3583                     ((LayoutPartInvalid)ws.Target).SetMarkup(markup);
3584                 }
3585                 catch (Exception e)
3586                 {
3587                     Eina.Log.Warning($"Callback error: {e.ToString()}");
3588                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
3589                 }
3590
3591
3592             }
3593             else
3594             {
3595                 efl_text_markup_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), markup);
3596             }
3597         }
3598
3599         private static efl_text_markup_set_delegate efl_text_markup_set_static_delegate;
3600
3601         [return: MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringPassOwnershipMarshaler))]
3602         private delegate System.String efl_text_markup_interactive_markup_range_get_delegate(System.IntPtr obj, System.IntPtr pd,  Efl.TextCursorCursor start,  Efl.TextCursorCursor end);
3603
3604         [return: MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringPassOwnershipMarshaler))]
3605         public delegate System.String efl_text_markup_interactive_markup_range_get_api_delegate(System.IntPtr obj,  Efl.TextCursorCursor start,  Efl.TextCursorCursor end);
3606
3607         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");
3608
3609         private static System.String markup_range_get(System.IntPtr obj, System.IntPtr pd, Efl.TextCursorCursor start, Efl.TextCursorCursor end)
3610         {
3611             Eina.Log.Debug("function efl_text_markup_interactive_markup_range_get was called");
3612             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
3613             if (ws != null)
3614             {
3615                                                             System.String _ret_var = default(System.String);
3616                 try
3617                 {
3618                     _ret_var = ((LayoutPartInvalid)ws.Target).GetMarkupRange(start, end);
3619                 }
3620                 catch (Exception e)
3621                 {
3622                     Eina.Log.Warning($"Callback error: {e.ToString()}");
3623                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
3624                 }
3625
3626                                         return _ret_var;
3627
3628             }
3629             else
3630             {
3631                 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);
3632             }
3633         }
3634
3635         private static efl_text_markup_interactive_markup_range_get_delegate efl_text_markup_interactive_markup_range_get_static_delegate;
3636
3637
3638         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);
3639
3640
3641         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);
3642
3643         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");
3644
3645         private static void markup_range_set(System.IntPtr obj, System.IntPtr pd, Efl.TextCursorCursor start, Efl.TextCursorCursor end, System.String markup)
3646         {
3647             Eina.Log.Debug("function efl_text_markup_interactive_markup_range_set was called");
3648             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
3649             if (ws != null)
3650             {
3651
3652                 try
3653                 {
3654                     ((LayoutPartInvalid)ws.Target).SetMarkupRange(start, end, markup);
3655                 }
3656                 catch (Exception e)
3657                 {
3658                     Eina.Log.Warning($"Callback error: {e.ToString()}");
3659                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
3660                 }
3661
3662
3663             }
3664             else
3665             {
3666                 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);
3667             }
3668         }
3669
3670         private static efl_text_markup_interactive_markup_range_set_delegate efl_text_markup_interactive_markup_range_set_static_delegate;
3671
3672
3673         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);
3674
3675
3676         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);
3677
3678         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");
3679
3680         private static void cursor_markup_insert(System.IntPtr obj, System.IntPtr pd, Efl.TextCursorCursor cur, System.String markup)
3681         {
3682             Eina.Log.Debug("function efl_text_markup_interactive_cursor_markup_insert was called");
3683             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
3684             if (ws != null)
3685             {
3686
3687                 try
3688                 {
3689                     ((LayoutPartInvalid)ws.Target).CursorMarkupInsert(cur, markup);
3690                 }
3691                 catch (Exception e)
3692                 {
3693                     Eina.Log.Warning($"Callback error: {e.ToString()}");
3694                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
3695                 }
3696
3697
3698             }
3699             else
3700             {
3701                 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);
3702             }
3703         }
3704
3705         private static efl_text_markup_interactive_cursor_markup_insert_delegate efl_text_markup_interactive_cursor_markup_insert_static_delegate;
3706
3707
3708         private delegate Efl.Ui.LayoutOrientation efl_ui_layout_orientation_get_delegate(System.IntPtr obj, System.IntPtr pd);
3709
3710
3711         public delegate Efl.Ui.LayoutOrientation efl_ui_layout_orientation_get_api_delegate(System.IntPtr obj);
3712
3713         public static Efl.Eo.FunctionWrapper<efl_ui_layout_orientation_get_api_delegate> efl_ui_layout_orientation_get_ptr = new Efl.Eo.FunctionWrapper<efl_ui_layout_orientation_get_api_delegate>(Module, "efl_ui_layout_orientation_get");
3714
3715         private static Efl.Ui.LayoutOrientation orientation_get(System.IntPtr obj, System.IntPtr pd)
3716         {
3717             Eina.Log.Debug("function efl_ui_layout_orientation_get was called");
3718             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
3719             if (ws != null)
3720             {
3721             Efl.Ui.LayoutOrientation _ret_var = default(Efl.Ui.LayoutOrientation);
3722                 try
3723                 {
3724                     _ret_var = ((LayoutPartInvalid)ws.Target).GetOrientation();
3725                 }
3726                 catch (Exception e)
3727                 {
3728                     Eina.Log.Warning($"Callback error: {e.ToString()}");
3729                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
3730                 }
3731
3732         return _ret_var;
3733
3734             }
3735             else
3736             {
3737                 return efl_ui_layout_orientation_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
3738             }
3739         }
3740
3741         private static efl_ui_layout_orientation_get_delegate efl_ui_layout_orientation_get_static_delegate;
3742
3743
3744         private delegate void efl_ui_layout_orientation_set_delegate(System.IntPtr obj, System.IntPtr pd,  Efl.Ui.LayoutOrientation dir);
3745
3746
3747         public delegate void efl_ui_layout_orientation_set_api_delegate(System.IntPtr obj,  Efl.Ui.LayoutOrientation dir);
3748
3749         public static Efl.Eo.FunctionWrapper<efl_ui_layout_orientation_set_api_delegate> efl_ui_layout_orientation_set_ptr = new Efl.Eo.FunctionWrapper<efl_ui_layout_orientation_set_api_delegate>(Module, "efl_ui_layout_orientation_set");
3750
3751         private static void orientation_set(System.IntPtr obj, System.IntPtr pd, Efl.Ui.LayoutOrientation dir)
3752         {
3753             Eina.Log.Debug("function efl_ui_layout_orientation_set was called");
3754             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
3755             if (ws != null)
3756             {
3757
3758                 try
3759                 {
3760                     ((LayoutPartInvalid)ws.Target).SetOrientation(dir);
3761                 }
3762                 catch (Exception e)
3763                 {
3764                     Eina.Log.Warning($"Callback error: {e.ToString()}");
3765                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
3766                 }
3767
3768
3769             }
3770             else
3771             {
3772                 efl_ui_layout_orientation_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), dir);
3773             }
3774         }
3775
3776         private static efl_ui_layout_orientation_set_delegate efl_ui_layout_orientation_set_static_delegate;
3777
3778         #pragma warning restore CA1707, CS1591, SA1300, SA1600
3779
3780 }
3781 }
3782 }
3783
3784 }
3785