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

   1 #define EFL_BETA
   2 #pragma warning disable CS1591
   3 using System;
   4 using System.Runtime.InteropServices;
   5 using System.Collections.Generic;
   6 using System.Linq;
   7 using System.Threading;
   8 using System.ComponentModel;
   9 namespace Efl {
  10
  11 namespace Canvas {
  12
  13 namespace Vg {
  14
  15 /// <summary>Efl vector graphics class</summary>
  16 /// <remarks>This is a <b>BETA</b> class. It can be modified or removed in the future. Do not use it for product development.</remarks>
  17 [Efl.Canvas.Vg.Object.NativeMethods]
  18 [Efl.Eo.BindingEntity]
  19 public class Object : Efl.Canvas.Object, Efl.IFile, Efl.IFileSave, Efl.Gfx.IFrameController
  20 {
  21     /// <summary>Pointer to the native class description.</summary>
  22     public override System.IntPtr NativeClass
  23     {
  24         get
  25         {
  26             if (((object)this).GetType() == typeof(Object))
  27             {
  28                 return GetEflClassStatic();
  29             }
  30             else
  31             {
  32                 return Efl.Eo.ClassRegister.klassFromType[((object)this).GetType()];
  33             }
  34         }
  35     }
  36
  37     [System.Runtime.InteropServices.DllImport(efl.Libs.Evas)] internal static extern System.IntPtr
  38         efl_canvas_vg_object_class_get();
  39     /// <summary>Initializes a new instance of the <see cref="Object"/> class.</summary>
  40     /// <param name="parent">Parent instance.</param>
  41     public Object(Efl.Object parent= null
  42             ) : base(efl_canvas_vg_object_class_get(), parent)
  43     {
  44         FinishInstantiation();
  45     }
  46
  47     /// <summary>Subclasses should override this constructor if they are expected to be instantiated from native code.
  48     /// Do not call this constructor directly.</summary>
  49     /// <param name="ch">Tag struct storing the native handle of the object being constructed.</param>
  50     protected Object(ConstructingHandle ch) : base(ch)
  51     {
  52     }
  53
  54     /// <summary>Initializes a new instance of the <see cref="Object"/> class.
  55     /// Internal usage: Constructs an instance from a native pointer. This is used when interacting with C code and should not be used directly.</summary>
  56     /// <param name="wh">The native pointer to be wrapped.</param>
  57     protected Object(Efl.Eo.Globals.WrappingHandle wh) : base(wh)
  58     {
  59     }
  60
  61     /// <summary>Initializes a new instance of the <see cref="Object"/> class.
  62     /// Internal usage: Constructor to forward the wrapper initialization to the root class that interfaces with native code. Should not be used directly.</summary>
  63     /// <param name="baseKlass">The pointer to the base native Eo class.</param>
  64     /// <param name="parent">The Efl.Object parent of this instance.</param>
  65     protected Object(IntPtr baseKlass, Efl.Object parent) : base(baseKlass, parent)
  66     {
  67     }
  68
  69     /// <summary>Control how the viewbox is mapped to the vg canvas&apos;s viewport.</summary>
  70     /// <returns>Fill mode type</returns>
  71     virtual public Efl.Canvas.Vg.FillMode GetFillMode() {
  72          var _ret_var = Efl.Canvas.Vg.Object.NativeMethods.efl_canvas_vg_object_fill_mode_get_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)));
  73         Eina.Error.RaiseIfUnhandledException();
  74         return _ret_var;
  75  }
  76     /// <summary>Control how the viewbox is mapped to the vg canvas&apos;s viewport.</summary>
  77     /// <param name="fill_mode">Fill mode type</param>
  78     virtual public void SetFillMode(Efl.Canvas.Vg.FillMode fill_mode) {
  79                                  Efl.Canvas.Vg.Object.NativeMethods.efl_canvas_vg_object_fill_mode_set_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)),fill_mode);
  80         Eina.Error.RaiseIfUnhandledException();
  81                          }
  82     /// <summary>Get the current viewbox from the  evas_object_vg</summary>
  83     /// <returns>viewbox for the vg canvas</returns>
  84     virtual public Eina.Rect GetViewbox() {
  85          var _ret_var = Efl.Canvas.Vg.Object.NativeMethods.efl_canvas_vg_object_viewbox_get_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)));
  86         Eina.Error.RaiseIfUnhandledException();
  87         return _ret_var;
  88  }
  89     /// <summary>Sets the viewbox for the evas vg canvas. viewbox if set should be mapped to the canvas geometry when rendering the vg tree.</summary>
  90     /// <param name="viewbox">viewbox for the vg canvas</param>
  91     virtual public void SetViewbox(Eina.Rect viewbox) {
  92          Eina.Rect.NativeStruct _in_viewbox = viewbox;
  93                         Efl.Canvas.Vg.Object.NativeMethods.efl_canvas_vg_object_viewbox_set_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)),_in_viewbox);
  94         Eina.Error.RaiseIfUnhandledException();
  95                          }
  96     /// <summary>Control how the viewbox is positioned inside the viewport.</summary>
  97     /// <param name="align_x">Alignment in the horizontal axis (0 &lt;= align_x &lt;= 1).</param>
  98     /// <param name="align_y">Alignment in the vertical axis (0 &lt;= align_y &lt;= 1).</param>
  99     virtual public void GetViewboxAlign(out double align_x, out double align_y) {
 100                                                          Efl.Canvas.Vg.Object.NativeMethods.efl_canvas_vg_object_viewbox_align_get_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)),out align_x, out align_y);
 101         Eina.Error.RaiseIfUnhandledException();
 102                                          }
 103     /// <summary>Control how the viewbox is positioned inside the viewport.</summary>
 104     /// <param name="align_x">Alignment in the horizontal axis (0 &lt;= align_x &lt;= 1).</param>
 105     /// <param name="align_y">Alignment in the vertical axis (0 &lt;= align_y &lt;= 1).</param>
 106     virtual public void SetViewboxAlign(double align_x, double align_y) {
 107                                                          Efl.Canvas.Vg.Object.NativeMethods.efl_canvas_vg_object_viewbox_align_set_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)),align_x, align_y);
 108         Eina.Error.RaiseIfUnhandledException();
 109                                          }
 110     /// <summary>Get the root node of the evas_object_vg.</summary>
 111     /// <returns>Root node of the VG canvas.</returns>
 112     virtual public Efl.Canvas.Vg.Node GetRootNode() {
 113          var _ret_var = Efl.Canvas.Vg.Object.NativeMethods.efl_canvas_vg_object_root_node_get_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)));
 114         Eina.Error.RaiseIfUnhandledException();
 115         return _ret_var;
 116  }
 117     /// <summary>Set the root node of the evas_object_vg.
 118     /// Note: To manually create the shape object and show in the Vg object canvas you must create the hierarchy and set as root node.
 119     ///
 120     /// It takes the ownership of the root node.</summary>
 121     /// <param name="root">Root node of the VG canvas.</param>
 122     virtual public void SetRootNode(Efl.Canvas.Vg.Node root) {
 123                                  Efl.Canvas.Vg.Object.NativeMethods.efl_canvas_vg_object_root_node_set_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)),root);
 124         Eina.Error.RaiseIfUnhandledException();
 125                          }
 126     /// <summary>Get the default vector size that specified from vector resource.
 127     /// (Since EFL 1.22)</summary>
 128     virtual public Eina.Size2D GetDefaultSize() {
 129          var _ret_var = Efl.Canvas.Vg.Object.NativeMethods.efl_canvas_vg_object_default_size_get_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)));
 130         Eina.Error.RaiseIfUnhandledException();
 131         return _ret_var;
 132  }
 133     /// <summary>Get the mmaped file from where an object will fetch the real data (it must be an <see cref="Eina.File"/>).
 134     /// (Since EFL 1.22)</summary>
 135     /// <returns>The handle to the <see cref="Eina.File"/> that will be used</returns>
 136     virtual public Eina.File GetMmap() {
 137          var _ret_var = Efl.IFileConcrete.NativeMethods.efl_file_mmap_get_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)));
 138         Eina.Error.RaiseIfUnhandledException();
 139         return _ret_var;
 140  }
 141     /// <summary>Set the mmaped file from where an object will fetch the real data (it must be an <see cref="Eina.File"/>).
 142     /// If mmap is set during object construction, the object will automatically call <see cref="Efl.IFile.Load"/> during the finalize phase of construction.
 143     /// (Since EFL 1.22)</summary>
 144     /// <param name="f">The handle to the <see cref="Eina.File"/> that will be used</param>
 145     /// <returns>0 on success, error code otherwise</returns>
 146     virtual public Eina.Error SetMmap(Eina.File f) {
 147                                  var _ret_var = Efl.IFileConcrete.NativeMethods.efl_file_mmap_set_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)),f);
 148         Eina.Error.RaiseIfUnhandledException();
 149                         return _ret_var;
 150  }
 151     /// <summary>Retrieve the file path from where an object is to fetch the data.
 152     /// You must not modify the strings on the returned pointers.
 153     /// (Since EFL 1.22)</summary>
 154     /// <returns>The file path.</returns>
 155     virtual public System.String GetFile() {
 156          var _ret_var = Efl.IFileConcrete.NativeMethods.efl_file_get_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)));
 157         Eina.Error.RaiseIfUnhandledException();
 158         return _ret_var;
 159  }
 160     /// <summary>Set the file path from where an object will fetch the data.
 161     /// If file is set during object construction, the object will automatically call <see cref="Efl.IFile.Load"/> during the finalize phase of construction.
 162     /// (Since EFL 1.22)</summary>
 163     /// <param name="file">The file path.</param>
 164     /// <returns>0 on success, error code otherwise</returns>
 165     virtual public Eina.Error SetFile(System.String file) {
 166                                  var _ret_var = Efl.IFileConcrete.NativeMethods.efl_file_set_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)),file);
 167         Eina.Error.RaiseIfUnhandledException();
 168                         return _ret_var;
 169  }
 170     /// <summary>Get the previously-set key which corresponds to the target data within a file.
 171     /// Some filetypes can contain multiple data streams which are indexed by a key. Use this property for such cases (See for example <see cref="Efl.Ui.Image"/> or <see cref="Efl.Ui.Layout"/>).
 172     ///
 173     /// You must not modify the strings on the returned pointers.
 174     /// (Since EFL 1.22)</summary>
 175     /// <returns>The group that the data belongs to. See the class documentation for particular implementations of this interface to see how this property is used.</returns>
 176     virtual public System.String GetKey() {
 177          var _ret_var = Efl.IFileConcrete.NativeMethods.efl_file_key_get_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)));
 178         Eina.Error.RaiseIfUnhandledException();
 179         return _ret_var;
 180  }
 181     /// <summary>Set the key which corresponds to the target data within a file.
 182     /// Some filetypes can contain multiple data streams which are indexed by a key. Use this property for such cases.
 183     /// (Since EFL 1.22)</summary>
 184     /// <param name="key">The group that the data belongs to. See the class documentation for particular implementations of this interface to see how this property is used.</param>
 185     virtual public void SetKey(System.String key) {
 186                                  Efl.IFileConcrete.NativeMethods.efl_file_key_set_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)),key);
 187         Eina.Error.RaiseIfUnhandledException();
 188                          }
 189     /// <summary>Get the load state of the object.
 190     /// (Since EFL 1.22)</summary>
 191     /// <returns><c>true</c> if the object is loaded, <c>false</c> otherwise.</returns>
 192     virtual public bool GetLoaded() {
 193          var _ret_var = Efl.IFileConcrete.NativeMethods.efl_file_loaded_get_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)));
 194         Eina.Error.RaiseIfUnhandledException();
 195         return _ret_var;
 196  }
 197     /// <summary>Perform all necessary operations to open and load file data into the object using the <see cref="Efl.IFile.File"/> (or <see cref="Efl.IFile.Mmap"/>) and <see cref="Efl.IFile.Key"/> properties.
 198     /// In the case where <see cref="Efl.IFile.SetFile"/> has been called on an object, this will internally open the file and call <see cref="Efl.IFile.SetMmap"/> on the object using the opened file handle.
 199     ///
 200     /// Calling <see cref="Efl.IFile.Load"/> on an object which has already performed file operations based on the currently set properties will have no effect.
 201     /// (Since EFL 1.22)</summary>
 202     /// <returns>0 on success, error code otherwise</returns>
 203     virtual public Eina.Error Load() {
 204          var _ret_var = Efl.IFileConcrete.NativeMethods.efl_file_load_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)));
 205         Eina.Error.RaiseIfUnhandledException();
 206         return _ret_var;
 207  }
 208     /// <summary>Perform all necessary operations to unload file data from the object.
 209     /// In the case where <see cref="Efl.IFile.SetMmap"/> has been externally called on an object, the file handle stored in the object will be preserved.
 210     ///
 211     /// Calling <see cref="Efl.IFile.Unload"/> on an object which is not currently loaded will have no effect.
 212     /// (Since EFL 1.22)</summary>
 213     virtual public void Unload() {
 214          Efl.IFileConcrete.NativeMethods.efl_file_unload_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)));
 215         Eina.Error.RaiseIfUnhandledException();
 216          }
 217     /// <summary>Save the given image object&apos;s contents to an (image) file.
 218     /// The extension suffix on <c>file</c> will determine which saver module Evas is to use when saving, thus the final file&apos;s format. If the file supports multiple data stored in it (Eet ones), you can specify the key to be used as the index of the image in it.
 219     ///
 220     /// You can specify some flags when saving the image.  Currently acceptable flags are <c>quality</c> and <c>compress</c>. Eg.: &quot;quality=100 compress=9&quot;.
 221     /// (Since EFL 1.22)</summary>
 222     /// <param name="file">The filename to be used to save the image (extension obligatory).</param>
 223     /// <param name="key">The image key in the file (if an Eet one), or <c>null</c>, otherwise.</param>
 224     /// <param name="info">The flags to be used (<c>null</c> for defaults).</param>
 225     /// <returns><c>true</c> on success, <c>false</c> otherwise</returns>
 226     virtual public bool Save(System.String file, System.String key, ref Efl.FileSaveInfo info) {
 227                          Efl.FileSaveInfo.NativeStruct _in_info = info;
 228                                                         var _ret_var = Efl.IFileSaveConcrete.NativeMethods.efl_file_save_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)),file, key, ref _in_info);
 229         Eina.Error.RaiseIfUnhandledException();
 230                                                 info = _in_info;
 231         return _ret_var;
 232  }
 233     /// <summary>Check if an object can be animated (has multiple frames).
 234     /// This will be <c>true</c> for animated object for instance but <c>false</c> for a single frame object.</summary>
 235     /// <returns><c>true</c> if the object is animated</returns>
 236     virtual public bool GetAnimated() {
 237          var _ret_var = Efl.Gfx.IFrameControllerConcrete.NativeMethods.efl_gfx_frame_controller_animated_get_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)));
 238         Eina.Error.RaiseIfUnhandledException();
 239         return _ret_var;
 240  }
 241     /// <summary>Index of the current frame of an animated object.
 242     /// Ranges from 1 to <see cref="Efl.Gfx.IFrameController.GetFrameCount"/>. Valid only if <see cref="Efl.Gfx.IFrameController.GetAnimated"/>.</summary>
 243     /// <returns>The index of current frame.</returns>
 244     virtual public int GetFrame() {
 245          var _ret_var = Efl.Gfx.IFrameControllerConcrete.NativeMethods.efl_gfx_frame_controller_frame_get_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)));
 246         Eina.Error.RaiseIfUnhandledException();
 247         return _ret_var;
 248  }
 249     /// <summary>Set the frame to current frame of an animated object.</summary>
 250     /// <param name="frame_index">The index of current frame.</param>
 251     /// <returns>Returns <c>true</c> if the frame index is valid.</returns>
 252     virtual public bool SetFrame(int frame_index) {
 253                                  var _ret_var = Efl.Gfx.IFrameControllerConcrete.NativeMethods.efl_gfx_frame_controller_frame_set_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)),frame_index);
 254         Eina.Error.RaiseIfUnhandledException();
 255                         return _ret_var;
 256  }
 257     /// <summary>Get the total number of frames of the object, if animated.
 258     /// Returns -1 if not animated.</summary>
 259     /// <returns>The number of frames in the animated object.</returns>
 260     virtual public int GetFrameCount() {
 261          var _ret_var = Efl.Gfx.IFrameControllerConcrete.NativeMethods.efl_gfx_frame_controller_frame_count_get_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)));
 262         Eina.Error.RaiseIfUnhandledException();
 263         return _ret_var;
 264  }
 265     /// <summary>Get the kind of looping the animated object does.
 266     /// This returns the kind of looping the animated object wants to do.
 267     ///
 268     /// If it returns <see cref="Efl.Gfx.FrameControllerLoopHint.Loop"/>, you should display frames in a sequence like: 1-&gt;2-&gt;3-&gt;1-&gt;2-&gt;3-&gt;1...
 269     ///
 270     /// If it returns <see cref="Efl.Gfx.FrameControllerLoopHint.Pingpong"/>, it is better to display frames in a sequence like: 1-&gt;2-&gt;3-&gt;2-&gt;1-&gt;2-&gt;3-&gt;1...
 271     ///
 272     /// The default type is <see cref="Efl.Gfx.FrameControllerLoopHint.Loop"/>.</summary>
 273     /// <returns>Loop type of the animated object.</returns>
 274     virtual public Efl.Gfx.FrameControllerLoopHint GetLoopType() {
 275          var _ret_var = Efl.Gfx.IFrameControllerConcrete.NativeMethods.efl_gfx_frame_controller_loop_type_get_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)));
 276         Eina.Error.RaiseIfUnhandledException();
 277         return _ret_var;
 278  }
 279     /// <summary>Get the number times the animation of the object loops.
 280     /// This returns loop count of animated object. The loop count is the number of times the animation will play fully from first to last frame until the animation should stop (at the final frame).
 281     ///
 282     /// If 0 is returned, then looping should happen indefinitely (no limit to the number of times it loops).</summary>
 283     /// <returns>The number of loop of an animated object.</returns>
 284     virtual public int GetLoopCount() {
 285          var _ret_var = Efl.Gfx.IFrameControllerConcrete.NativeMethods.efl_gfx_frame_controller_loop_count_get_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)));
 286         Eina.Error.RaiseIfUnhandledException();
 287         return _ret_var;
 288  }
 289     /// <summary>Get the duration of a sequence of frames.
 290     /// This returns total duration in seconds that the specified sequence of frames should take.
 291     ///
 292     /// If <c>start_frame</c> is 1 and <c>frame_num</c> is 0, this returns the duration of frame 1. If <c>start_frame</c> is 1 and <c>frame_num</c> is 1, this returns the total duration of frame 1 + frame 2.</summary>
 293     /// <param name="start_frame">The first frame, rangers from 1 to <see cref="Efl.Gfx.IFrameController.GetFrameCount"/>.</param>
 294     /// <param name="frame_num">Number of frames in the sequence, starts from 0.</param>
 295     /// <returns>Duration in seconds</returns>
 296     virtual public double GetFrameDuration(int start_frame, int frame_num) {
 297                                                          var _ret_var = Efl.Gfx.IFrameControllerConcrete.NativeMethods.efl_gfx_frame_controller_frame_duration_get_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)),start_frame, frame_num);
 298         Eina.Error.RaiseIfUnhandledException();
 299                                         return _ret_var;
 300  }
 301     /// <summary>Control how the viewbox is mapped to the vg canvas&apos;s viewport.</summary>
 302     /// <value>Fill mode type</value>
 303     public Efl.Canvas.Vg.FillMode FillMode {
 304         get { return GetFillMode(); }
 305         set { SetFillMode(value); }
 306     }
 307     /// <summary>Get the current viewbox from the  evas_object_vg</summary>
 308     /// <value>viewbox for the vg canvas</value>
 309     public Eina.Rect Viewbox {
 310         get { return GetViewbox(); }
 311         set { SetViewbox(value); }
 312     }
 313     /// <summary>Control how the viewbox is positioned inside the viewport.</summary>
 314     /// <value>Alignment in the horizontal axis (0 &lt;= align_x &lt;= 1).</value>
 315     public (double, double) ViewboxAlign {
 316         get {
 317             double _out_align_x = default(double);
 318             double _out_align_y = default(double);
 319             GetViewboxAlign(out _out_align_x,out _out_align_y);
 320             return (_out_align_x,_out_align_y);
 321         }
 322         set { SetViewboxAlign( value.Item1,  value.Item2); }
 323     }
 324     /// <summary>Get the root node of the evas_object_vg.</summary>
 325     /// <value>Root node of the VG canvas.</value>
 326     public Efl.Canvas.Vg.Node RootNode {
 327         get { return GetRootNode(); }
 328         set { SetRootNode(value); }
 329     }
 330     /// <summary>Get the default vector size that specified from vector resource.
 331     /// (Since EFL 1.22)</summary>
 332     public Eina.Size2D DefaultSize {
 333         get { return GetDefaultSize(); }
 334     }
 335     /// <summary>Get the mmaped file from where an object will fetch the real data (it must be an <see cref="Eina.File"/>).
 336     /// (Since EFL 1.22)</summary>
 337     /// <value>The handle to the <see cref="Eina.File"/> that will be used</value>
 338     public Eina.File Mmap {
 339         get { return GetMmap(); }
 340         set { SetMmap(value); }
 341     }
 342     /// <summary>Retrieve the file path from where an object is to fetch the data.
 343     /// You must not modify the strings on the returned pointers.
 344     /// (Since EFL 1.22)</summary>
 345     /// <value>The file path.</value>
 346     public System.String File {
 347         get { return GetFile(); }
 348         set { SetFile(value); }
 349     }
 350     /// <summary>Get the previously-set key which corresponds to the target data within a file.
 351     /// Some filetypes can contain multiple data streams which are indexed by a key. Use this property for such cases (See for example <see cref="Efl.Ui.Image"/> or <see cref="Efl.Ui.Layout"/>).
 352     ///
 353     /// You must not modify the strings on the returned pointers.
 354     /// (Since EFL 1.22)</summary>
 355     /// <value>The group that the data belongs to. See the class documentation for particular implementations of this interface to see how this property is used.</value>
 356     public System.String Key {
 357         get { return GetKey(); }
 358         set { SetKey(value); }
 359     }
 360     /// <summary>Get the load state of the object.
 361     /// (Since EFL 1.22)</summary>
 362     /// <value><c>true</c> if the object is loaded, <c>false</c> otherwise.</value>
 363     public bool Loaded {
 364         get { return GetLoaded(); }
 365     }
 366     /// <summary>Check if an object can be animated (has multiple frames).
 367     /// This will be <c>true</c> for animated object for instance but <c>false</c> for a single frame object.</summary>
 368     /// <value><c>true</c> if the object is animated</value>
 369     public bool Animated {
 370         get { return GetAnimated(); }
 371     }
 372     /// <summary>Index of the current frame of an animated object.
 373     /// Ranges from 1 to <see cref="Efl.Gfx.IFrameController.GetFrameCount"/>. Valid only if <see cref="Efl.Gfx.IFrameController.GetAnimated"/>.</summary>
 374     /// <value>The index of current frame.</value>
 375     public int Frame {
 376         get { return GetFrame(); }
 377         set { SetFrame(value); }
 378     }
 379     /// <summary>Get the total number of frames of the object, if animated.
 380     /// Returns -1 if not animated.</summary>
 381     /// <value>The number of frames in the animated object.</value>
 382     public int FrameCount {
 383         get { return GetFrameCount(); }
 384     }
 385     /// <summary>Get the kind of looping the animated object does.
 386     /// This returns the kind of looping the animated object wants to do.
 387     ///
 388     /// If it returns <see cref="Efl.Gfx.FrameControllerLoopHint.Loop"/>, you should display frames in a sequence like: 1-&gt;2-&gt;3-&gt;1-&gt;2-&gt;3-&gt;1...
 389     ///
 390     /// If it returns <see cref="Efl.Gfx.FrameControllerLoopHint.Pingpong"/>, it is better to display frames in a sequence like: 1-&gt;2-&gt;3-&gt;2-&gt;1-&gt;2-&gt;3-&gt;1...
 391     ///
 392     /// The default type is <see cref="Efl.Gfx.FrameControllerLoopHint.Loop"/>.</summary>
 393     /// <value>Loop type of the animated object.</value>
 394     public Efl.Gfx.FrameControllerLoopHint LoopType {
 395         get { return GetLoopType(); }
 396     }
 397     /// <summary>Get the number times the animation of the object loops.
 398     /// This returns loop count of animated object. The loop count is the number of times the animation will play fully from first to last frame until the animation should stop (at the final frame).
 399     ///
 400     /// If 0 is returned, then looping should happen indefinitely (no limit to the number of times it loops).</summary>
 401     /// <value>The number of loop of an animated object.</value>
 402     public int LoopCount {
 403         get { return GetLoopCount(); }
 404     }
 405     private static IntPtr GetEflClassStatic()
 406     {
 407         return Efl.Canvas.Vg.Object.efl_canvas_vg_object_class_get();
 408     }
 409     /// <summary>Wrapper for native methods and virtual method delegates.
 410     /// For internal use by generated code only.</summary>
 411     public new class NativeMethods : Efl.Canvas.Object.NativeMethods
 412     {
 413         private static Efl.Eo.NativeModule Module = new Efl.Eo.NativeModule(    efl.Libs.Evas);
 414         /// <summary>Gets the list of Eo operations to override.</summary>
 415         /// <returns>The list of Eo operations to be overload.</returns>
 416         public override System.Collections.Generic.List<Efl_Op_Description> GetEoOps(System.Type type)
 417         {
 418             var descs = new System.Collections.Generic.List<Efl_Op_Description>();
 419             var methods = Efl.Eo.Globals.GetUserMethods(type);
 420
 421             if (efl_canvas_vg_object_fill_mode_get_static_delegate == null)
 422             {
 423                 efl_canvas_vg_object_fill_mode_get_static_delegate = new efl_canvas_vg_object_fill_mode_get_delegate(fill_mode_get);
 424             }
 425
 426             if (methods.FirstOrDefault(m => m.Name == "GetFillMode") != null)
 427             {
 428                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_canvas_vg_object_fill_mode_get"), func = Marshal.GetFunctionPointerForDelegate(efl_canvas_vg_object_fill_mode_get_static_delegate) });
 429             }
 430
 431             if (efl_canvas_vg_object_fill_mode_set_static_delegate == null)
 432             {
 433                 efl_canvas_vg_object_fill_mode_set_static_delegate = new efl_canvas_vg_object_fill_mode_set_delegate(fill_mode_set);
 434             }
 435
 436             if (methods.FirstOrDefault(m => m.Name == "SetFillMode") != null)
 437             {
 438                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_canvas_vg_object_fill_mode_set"), func = Marshal.GetFunctionPointerForDelegate(efl_canvas_vg_object_fill_mode_set_static_delegate) });
 439             }
 440
 441             if (efl_canvas_vg_object_viewbox_get_static_delegate == null)
 442             {
 443                 efl_canvas_vg_object_viewbox_get_static_delegate = new efl_canvas_vg_object_viewbox_get_delegate(viewbox_get);
 444             }
 445
 446             if (methods.FirstOrDefault(m => m.Name == "GetViewbox") != null)
 447             {
 448                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_canvas_vg_object_viewbox_get"), func = Marshal.GetFunctionPointerForDelegate(efl_canvas_vg_object_viewbox_get_static_delegate) });
 449             }
 450
 451             if (efl_canvas_vg_object_viewbox_set_static_delegate == null)
 452             {
 453                 efl_canvas_vg_object_viewbox_set_static_delegate = new efl_canvas_vg_object_viewbox_set_delegate(viewbox_set);
 454             }
 455
 456             if (methods.FirstOrDefault(m => m.Name == "SetViewbox") != null)
 457             {
 458                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_canvas_vg_object_viewbox_set"), func = Marshal.GetFunctionPointerForDelegate(efl_canvas_vg_object_viewbox_set_static_delegate) });
 459             }
 460
 461             if (efl_canvas_vg_object_viewbox_align_get_static_delegate == null)
 462             {
 463                 efl_canvas_vg_object_viewbox_align_get_static_delegate = new efl_canvas_vg_object_viewbox_align_get_delegate(viewbox_align_get);
 464             }
 465
 466             if (methods.FirstOrDefault(m => m.Name == "GetViewboxAlign") != null)
 467             {
 468                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_canvas_vg_object_viewbox_align_get"), func = Marshal.GetFunctionPointerForDelegate(efl_canvas_vg_object_viewbox_align_get_static_delegate) });
 469             }
 470
 471             if (efl_canvas_vg_object_viewbox_align_set_static_delegate == null)
 472             {
 473                 efl_canvas_vg_object_viewbox_align_set_static_delegate = new efl_canvas_vg_object_viewbox_align_set_delegate(viewbox_align_set);
 474             }
 475
 476             if (methods.FirstOrDefault(m => m.Name == "SetViewboxAlign") != null)
 477             {
 478                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_canvas_vg_object_viewbox_align_set"), func = Marshal.GetFunctionPointerForDelegate(efl_canvas_vg_object_viewbox_align_set_static_delegate) });
 479             }
 480
 481             if (efl_canvas_vg_object_root_node_get_static_delegate == null)
 482             {
 483                 efl_canvas_vg_object_root_node_get_static_delegate = new efl_canvas_vg_object_root_node_get_delegate(root_node_get);
 484             }
 485
 486             if (methods.FirstOrDefault(m => m.Name == "GetRootNode") != null)
 487             {
 488                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_canvas_vg_object_root_node_get"), func = Marshal.GetFunctionPointerForDelegate(efl_canvas_vg_object_root_node_get_static_delegate) });
 489             }
 490
 491             if (efl_canvas_vg_object_root_node_set_static_delegate == null)
 492             {
 493                 efl_canvas_vg_object_root_node_set_static_delegate = new efl_canvas_vg_object_root_node_set_delegate(root_node_set);
 494             }
 495
 496             if (methods.FirstOrDefault(m => m.Name == "SetRootNode") != null)
 497             {
 498                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_canvas_vg_object_root_node_set"), func = Marshal.GetFunctionPointerForDelegate(efl_canvas_vg_object_root_node_set_static_delegate) });
 499             }
 500
 501             if (efl_canvas_vg_object_default_size_get_static_delegate == null)
 502             {
 503                 efl_canvas_vg_object_default_size_get_static_delegate = new efl_canvas_vg_object_default_size_get_delegate(default_size_get);
 504             }
 505
 506             if (methods.FirstOrDefault(m => m.Name == "GetDefaultSize") != null)
 507             {
 508                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_canvas_vg_object_default_size_get"), func = Marshal.GetFunctionPointerForDelegate(efl_canvas_vg_object_default_size_get_static_delegate) });
 509             }
 510
 511             if (efl_file_mmap_get_static_delegate == null)
 512             {
 513                 efl_file_mmap_get_static_delegate = new efl_file_mmap_get_delegate(mmap_get);
 514             }
 515
 516             if (methods.FirstOrDefault(m => m.Name == "GetMmap") != null)
 517             {
 518                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_file_mmap_get"), func = Marshal.GetFunctionPointerForDelegate(efl_file_mmap_get_static_delegate) });
 519             }
 520
 521             if (efl_file_mmap_set_static_delegate == null)
 522             {
 523                 efl_file_mmap_set_static_delegate = new efl_file_mmap_set_delegate(mmap_set);
 524             }
 525
 526             if (methods.FirstOrDefault(m => m.Name == "SetMmap") != null)
 527             {
 528                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_file_mmap_set"), func = Marshal.GetFunctionPointerForDelegate(efl_file_mmap_set_static_delegate) });
 529             }
 530
 531             if (efl_file_get_static_delegate == null)
 532             {
 533                 efl_file_get_static_delegate = new efl_file_get_delegate(file_get);
 534             }
 535
 536             if (methods.FirstOrDefault(m => m.Name == "GetFile") != null)
 537             {
 538                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_file_get"), func = Marshal.GetFunctionPointerForDelegate(efl_file_get_static_delegate) });
 539             }
 540
 541             if (efl_file_set_static_delegate == null)
 542             {
 543                 efl_file_set_static_delegate = new efl_file_set_delegate(file_set);
 544             }
 545
 546             if (methods.FirstOrDefault(m => m.Name == "SetFile") != null)
 547             {
 548                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_file_set"), func = Marshal.GetFunctionPointerForDelegate(efl_file_set_static_delegate) });
 549             }
 550
 551             if (efl_file_key_get_static_delegate == null)
 552             {
 553                 efl_file_key_get_static_delegate = new efl_file_key_get_delegate(key_get);
 554             }
 555
 556             if (methods.FirstOrDefault(m => m.Name == "GetKey") != null)
 557             {
 558                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_file_key_get"), func = Marshal.GetFunctionPointerForDelegate(efl_file_key_get_static_delegate) });
 559             }
 560
 561             if (efl_file_key_set_static_delegate == null)
 562             {
 563                 efl_file_key_set_static_delegate = new efl_file_key_set_delegate(key_set);
 564             }
 565
 566             if (methods.FirstOrDefault(m => m.Name == "SetKey") != null)
 567             {
 568                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_file_key_set"), func = Marshal.GetFunctionPointerForDelegate(efl_file_key_set_static_delegate) });
 569             }
 570
 571             if (efl_file_loaded_get_static_delegate == null)
 572             {
 573                 efl_file_loaded_get_static_delegate = new efl_file_loaded_get_delegate(loaded_get);
 574             }
 575
 576             if (methods.FirstOrDefault(m => m.Name == "GetLoaded") != null)
 577             {
 578                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_file_loaded_get"), func = Marshal.GetFunctionPointerForDelegate(efl_file_loaded_get_static_delegate) });
 579             }
 580
 581             if (efl_file_load_static_delegate == null)
 582             {
 583                 efl_file_load_static_delegate = new efl_file_load_delegate(load);
 584             }
 585
 586             if (methods.FirstOrDefault(m => m.Name == "Load") != null)
 587             {
 588                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_file_load"), func = Marshal.GetFunctionPointerForDelegate(efl_file_load_static_delegate) });
 589             }
 590
 591             if (efl_file_unload_static_delegate == null)
 592             {
 593                 efl_file_unload_static_delegate = new efl_file_unload_delegate(unload);
 594             }
 595
 596             if (methods.FirstOrDefault(m => m.Name == "Unload") != null)
 597             {
 598                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_file_unload"), func = Marshal.GetFunctionPointerForDelegate(efl_file_unload_static_delegate) });
 599             }
 600
 601             if (efl_file_save_static_delegate == null)
 602             {
 603                 efl_file_save_static_delegate = new efl_file_save_delegate(save);
 604             }
 605
 606             if (methods.FirstOrDefault(m => m.Name == "Save") != null)
 607             {
 608                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_file_save"), func = Marshal.GetFunctionPointerForDelegate(efl_file_save_static_delegate) });
 609             }
 610
 611             if (efl_gfx_frame_controller_animated_get_static_delegate == null)
 612             {
 613                 efl_gfx_frame_controller_animated_get_static_delegate = new efl_gfx_frame_controller_animated_get_delegate(animated_get);
 614             }
 615
 616             if (methods.FirstOrDefault(m => m.Name == "GetAnimated") != null)
 617             {
 618                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_gfx_frame_controller_animated_get"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_frame_controller_animated_get_static_delegate) });
 619             }
 620
 621             if (efl_gfx_frame_controller_frame_get_static_delegate == null)
 622             {
 623                 efl_gfx_frame_controller_frame_get_static_delegate = new efl_gfx_frame_controller_frame_get_delegate(frame_get);
 624             }
 625
 626             if (methods.FirstOrDefault(m => m.Name == "GetFrame") != null)
 627             {
 628                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_gfx_frame_controller_frame_get"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_frame_controller_frame_get_static_delegate) });
 629             }
 630
 631             if (efl_gfx_frame_controller_frame_set_static_delegate == null)
 632             {
 633                 efl_gfx_frame_controller_frame_set_static_delegate = new efl_gfx_frame_controller_frame_set_delegate(frame_set);
 634             }
 635
 636             if (methods.FirstOrDefault(m => m.Name == "SetFrame") != null)
 637             {
 638                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_gfx_frame_controller_frame_set"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_frame_controller_frame_set_static_delegate) });
 639             }
 640
 641             if (efl_gfx_frame_controller_frame_count_get_static_delegate == null)
 642             {
 643                 efl_gfx_frame_controller_frame_count_get_static_delegate = new efl_gfx_frame_controller_frame_count_get_delegate(frame_count_get);
 644             }
 645
 646             if (methods.FirstOrDefault(m => m.Name == "GetFrameCount") != null)
 647             {
 648                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_gfx_frame_controller_frame_count_get"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_frame_controller_frame_count_get_static_delegate) });
 649             }
 650
 651             if (efl_gfx_frame_controller_loop_type_get_static_delegate == null)
 652             {
 653                 efl_gfx_frame_controller_loop_type_get_static_delegate = new efl_gfx_frame_controller_loop_type_get_delegate(loop_type_get);
 654             }
 655
 656             if (methods.FirstOrDefault(m => m.Name == "GetLoopType") != null)
 657             {
 658                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_gfx_frame_controller_loop_type_get"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_frame_controller_loop_type_get_static_delegate) });
 659             }
 660
 661             if (efl_gfx_frame_controller_loop_count_get_static_delegate == null)
 662             {
 663                 efl_gfx_frame_controller_loop_count_get_static_delegate = new efl_gfx_frame_controller_loop_count_get_delegate(loop_count_get);
 664             }
 665
 666             if (methods.FirstOrDefault(m => m.Name == "GetLoopCount") != null)
 667             {
 668                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_gfx_frame_controller_loop_count_get"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_frame_controller_loop_count_get_static_delegate) });
 669             }
 670
 671             if (efl_gfx_frame_controller_frame_duration_get_static_delegate == null)
 672             {
 673                 efl_gfx_frame_controller_frame_duration_get_static_delegate = new efl_gfx_frame_controller_frame_duration_get_delegate(frame_duration_get);
 674             }
 675
 676             if (methods.FirstOrDefault(m => m.Name == "GetFrameDuration") != null)
 677             {
 678                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_gfx_frame_controller_frame_duration_get"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_frame_controller_frame_duration_get_static_delegate) });
 679             }
 680
 681             descs.AddRange(base.GetEoOps(type));
 682             return descs;
 683         }
 684         /// <summary>Returns the Eo class for the native methods of this class.</summary>
 685         /// <returns>The native class pointer.</returns>
 686         public override IntPtr GetEflClass()
 687         {
 688             return Efl.Canvas.Vg.Object.efl_canvas_vg_object_class_get();
 689         }
 690
 691         #pragma warning disable CA1707, CS1591, SA1300, SA1600
 692
 693
 694         private delegate Efl.Canvas.Vg.FillMode efl_canvas_vg_object_fill_mode_get_delegate(System.IntPtr obj, System.IntPtr pd);
 695
 696
 697         public delegate Efl.Canvas.Vg.FillMode efl_canvas_vg_object_fill_mode_get_api_delegate(System.IntPtr obj);
 698
 699         public static Efl.Eo.FunctionWrapper<efl_canvas_vg_object_fill_mode_get_api_delegate> efl_canvas_vg_object_fill_mode_get_ptr = new Efl.Eo.FunctionWrapper<efl_canvas_vg_object_fill_mode_get_api_delegate>(Module, "efl_canvas_vg_object_fill_mode_get");
 700
 701         private static Efl.Canvas.Vg.FillMode fill_mode_get(System.IntPtr obj, System.IntPtr pd)
 702         {
 703             Eina.Log.Debug("function efl_canvas_vg_object_fill_mode_get was called");
 704             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 705             if (ws != null)
 706             {
 707             Efl.Canvas.Vg.FillMode _ret_var = default(Efl.Canvas.Vg.FillMode);
 708                 try
 709                 {
 710                     _ret_var = ((Object)ws.Target).GetFillMode();
 711                 }
 712                 catch (Exception e)
 713                 {
 714                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 715                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 716                 }
 717
 718         return _ret_var;
 719
 720             }
 721             else
 722             {
 723                 return efl_canvas_vg_object_fill_mode_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
 724             }
 725         }
 726
 727         private static efl_canvas_vg_object_fill_mode_get_delegate efl_canvas_vg_object_fill_mode_get_static_delegate;
 728
 729
 730         private delegate void efl_canvas_vg_object_fill_mode_set_delegate(System.IntPtr obj, System.IntPtr pd,  Efl.Canvas.Vg.FillMode fill_mode);
 731
 732
 733         public delegate void efl_canvas_vg_object_fill_mode_set_api_delegate(System.IntPtr obj,  Efl.Canvas.Vg.FillMode fill_mode);
 734
 735         public static Efl.Eo.FunctionWrapper<efl_canvas_vg_object_fill_mode_set_api_delegate> efl_canvas_vg_object_fill_mode_set_ptr = new Efl.Eo.FunctionWrapper<efl_canvas_vg_object_fill_mode_set_api_delegate>(Module, "efl_canvas_vg_object_fill_mode_set");
 736
 737         private static void fill_mode_set(System.IntPtr obj, System.IntPtr pd, Efl.Canvas.Vg.FillMode fill_mode)
 738         {
 739             Eina.Log.Debug("function efl_canvas_vg_object_fill_mode_set was called");
 740             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 741             if (ws != null)
 742             {
 743
 744                 try
 745                 {
 746                     ((Object)ws.Target).SetFillMode(fill_mode);
 747                 }
 748                 catch (Exception e)
 749                 {
 750                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 751                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 752                 }
 753
 754
 755             }
 756             else
 757             {
 758                 efl_canvas_vg_object_fill_mode_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), fill_mode);
 759             }
 760         }
 761
 762         private static efl_canvas_vg_object_fill_mode_set_delegate efl_canvas_vg_object_fill_mode_set_static_delegate;
 763
 764
 765         private delegate Eina.Rect.NativeStruct efl_canvas_vg_object_viewbox_get_delegate(System.IntPtr obj, System.IntPtr pd);
 766
 767
 768         public delegate Eina.Rect.NativeStruct efl_canvas_vg_object_viewbox_get_api_delegate(System.IntPtr obj);
 769
 770         public static Efl.Eo.FunctionWrapper<efl_canvas_vg_object_viewbox_get_api_delegate> efl_canvas_vg_object_viewbox_get_ptr = new Efl.Eo.FunctionWrapper<efl_canvas_vg_object_viewbox_get_api_delegate>(Module, "efl_canvas_vg_object_viewbox_get");
 771
 772         private static Eina.Rect.NativeStruct viewbox_get(System.IntPtr obj, System.IntPtr pd)
 773         {
 774             Eina.Log.Debug("function efl_canvas_vg_object_viewbox_get was called");
 775             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 776             if (ws != null)
 777             {
 778             Eina.Rect _ret_var = default(Eina.Rect);
 779                 try
 780                 {
 781                     _ret_var = ((Object)ws.Target).GetViewbox();
 782                 }
 783                 catch (Exception e)
 784                 {
 785                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 786                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 787                 }
 788
 789         return _ret_var;
 790
 791             }
 792             else
 793             {
 794                 return efl_canvas_vg_object_viewbox_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
 795             }
 796         }
 797
 798         private static efl_canvas_vg_object_viewbox_get_delegate efl_canvas_vg_object_viewbox_get_static_delegate;
 799
 800
 801         private delegate void efl_canvas_vg_object_viewbox_set_delegate(System.IntPtr obj, System.IntPtr pd,  Eina.Rect.NativeStruct viewbox);
 802
 803
 804         public delegate void efl_canvas_vg_object_viewbox_set_api_delegate(System.IntPtr obj,  Eina.Rect.NativeStruct viewbox);
 805
 806         public static Efl.Eo.FunctionWrapper<efl_canvas_vg_object_viewbox_set_api_delegate> efl_canvas_vg_object_viewbox_set_ptr = new Efl.Eo.FunctionWrapper<efl_canvas_vg_object_viewbox_set_api_delegate>(Module, "efl_canvas_vg_object_viewbox_set");
 807
 808         private static void viewbox_set(System.IntPtr obj, System.IntPtr pd, Eina.Rect.NativeStruct viewbox)
 809         {
 810             Eina.Log.Debug("function efl_canvas_vg_object_viewbox_set was called");
 811             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 812             if (ws != null)
 813             {
 814         Eina.Rect _in_viewbox = viewbox;
 815
 816                 try
 817                 {
 818                     ((Object)ws.Target).SetViewbox(_in_viewbox);
 819                 }
 820                 catch (Exception e)
 821                 {
 822                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 823                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 824                 }
 825
 826
 827             }
 828             else
 829             {
 830                 efl_canvas_vg_object_viewbox_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), viewbox);
 831             }
 832         }
 833
 834         private static efl_canvas_vg_object_viewbox_set_delegate efl_canvas_vg_object_viewbox_set_static_delegate;
 835
 836
 837         private delegate void efl_canvas_vg_object_viewbox_align_get_delegate(System.IntPtr obj, System.IntPtr pd,  out double align_x,  out double align_y);
 838
 839
 840         public delegate void efl_canvas_vg_object_viewbox_align_get_api_delegate(System.IntPtr obj,  out double align_x,  out double align_y);
 841
 842         public static Efl.Eo.FunctionWrapper<efl_canvas_vg_object_viewbox_align_get_api_delegate> efl_canvas_vg_object_viewbox_align_get_ptr = new Efl.Eo.FunctionWrapper<efl_canvas_vg_object_viewbox_align_get_api_delegate>(Module, "efl_canvas_vg_object_viewbox_align_get");
 843
 844         private static void viewbox_align_get(System.IntPtr obj, System.IntPtr pd, out double align_x, out double align_y)
 845         {
 846             Eina.Log.Debug("function efl_canvas_vg_object_viewbox_align_get was called");
 847             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 848             if (ws != null)
 849             {
 850                         align_x = default(double);        align_y = default(double);
 851                 try
 852                 {
 853                     ((Object)ws.Target).GetViewboxAlign(out align_x, out align_y);
 854                 }
 855                 catch (Exception e)
 856                 {
 857                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 858                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 859                 }
 860
 861
 862             }
 863             else
 864             {
 865                 efl_canvas_vg_object_viewbox_align_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), out align_x, out align_y);
 866             }
 867         }
 868
 869         private static efl_canvas_vg_object_viewbox_align_get_delegate efl_canvas_vg_object_viewbox_align_get_static_delegate;
 870
 871
 872         private delegate void efl_canvas_vg_object_viewbox_align_set_delegate(System.IntPtr obj, System.IntPtr pd,  double align_x,  double align_y);
 873
 874
 875         public delegate void efl_canvas_vg_object_viewbox_align_set_api_delegate(System.IntPtr obj,  double align_x,  double align_y);
 876
 877         public static Efl.Eo.FunctionWrapper<efl_canvas_vg_object_viewbox_align_set_api_delegate> efl_canvas_vg_object_viewbox_align_set_ptr = new Efl.Eo.FunctionWrapper<efl_canvas_vg_object_viewbox_align_set_api_delegate>(Module, "efl_canvas_vg_object_viewbox_align_set");
 878
 879         private static void viewbox_align_set(System.IntPtr obj, System.IntPtr pd, double align_x, double align_y)
 880         {
 881             Eina.Log.Debug("function efl_canvas_vg_object_viewbox_align_set was called");
 882             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 883             if (ws != null)
 884             {
 885
 886                 try
 887                 {
 888                     ((Object)ws.Target).SetViewboxAlign(align_x, align_y);
 889                 }
 890                 catch (Exception e)
 891                 {
 892                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 893                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 894                 }
 895
 896
 897             }
 898             else
 899             {
 900                 efl_canvas_vg_object_viewbox_align_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), align_x, align_y);
 901             }
 902         }
 903
 904         private static efl_canvas_vg_object_viewbox_align_set_delegate efl_canvas_vg_object_viewbox_align_set_static_delegate;
 905
 906         [return:MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))]
 907         private delegate Efl.Canvas.Vg.Node efl_canvas_vg_object_root_node_get_delegate(System.IntPtr obj, System.IntPtr pd);
 908
 909         [return:MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))]
 910         public delegate Efl.Canvas.Vg.Node efl_canvas_vg_object_root_node_get_api_delegate(System.IntPtr obj);
 911
 912         public static Efl.Eo.FunctionWrapper<efl_canvas_vg_object_root_node_get_api_delegate> efl_canvas_vg_object_root_node_get_ptr = new Efl.Eo.FunctionWrapper<efl_canvas_vg_object_root_node_get_api_delegate>(Module, "efl_canvas_vg_object_root_node_get");
 913
 914         private static Efl.Canvas.Vg.Node root_node_get(System.IntPtr obj, System.IntPtr pd)
 915         {
 916             Eina.Log.Debug("function efl_canvas_vg_object_root_node_get was called");
 917             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 918             if (ws != null)
 919             {
 920             Efl.Canvas.Vg.Node _ret_var = default(Efl.Canvas.Vg.Node);
 921                 try
 922                 {
 923                     _ret_var = ((Object)ws.Target).GetRootNode();
 924                 }
 925                 catch (Exception e)
 926                 {
 927                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 928                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 929                 }
 930
 931         return _ret_var;
 932
 933             }
 934             else
 935             {
 936                 return efl_canvas_vg_object_root_node_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
 937             }
 938         }
 939
 940         private static efl_canvas_vg_object_root_node_get_delegate efl_canvas_vg_object_root_node_get_static_delegate;
 941
 942
 943         private delegate void efl_canvas_vg_object_root_node_set_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))] Efl.Canvas.Vg.Node root);
 944
 945
 946         public delegate void efl_canvas_vg_object_root_node_set_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))] Efl.Canvas.Vg.Node root);
 947
 948         public static Efl.Eo.FunctionWrapper<efl_canvas_vg_object_root_node_set_api_delegate> efl_canvas_vg_object_root_node_set_ptr = new Efl.Eo.FunctionWrapper<efl_canvas_vg_object_root_node_set_api_delegate>(Module, "efl_canvas_vg_object_root_node_set");
 949
 950         private static void root_node_set(System.IntPtr obj, System.IntPtr pd, Efl.Canvas.Vg.Node root)
 951         {
 952             Eina.Log.Debug("function efl_canvas_vg_object_root_node_set was called");
 953             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 954             if (ws != null)
 955             {
 956
 957                 try
 958                 {
 959                     ((Object)ws.Target).SetRootNode(root);
 960                 }
 961                 catch (Exception e)
 962                 {
 963                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 964                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 965                 }
 966
 967
 968             }
 969             else
 970             {
 971                 efl_canvas_vg_object_root_node_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), root);
 972             }
 973         }
 974
 975         private static efl_canvas_vg_object_root_node_set_delegate efl_canvas_vg_object_root_node_set_static_delegate;
 976
 977
 978         private delegate Eina.Size2D.NativeStruct efl_canvas_vg_object_default_size_get_delegate(System.IntPtr obj, System.IntPtr pd);
 979
 980
 981         public delegate Eina.Size2D.NativeStruct efl_canvas_vg_object_default_size_get_api_delegate(System.IntPtr obj);
 982
 983         public static Efl.Eo.FunctionWrapper<efl_canvas_vg_object_default_size_get_api_delegate> efl_canvas_vg_object_default_size_get_ptr = new Efl.Eo.FunctionWrapper<efl_canvas_vg_object_default_size_get_api_delegate>(Module, "efl_canvas_vg_object_default_size_get");
 984
 985         private static Eina.Size2D.NativeStruct default_size_get(System.IntPtr obj, System.IntPtr pd)
 986         {
 987             Eina.Log.Debug("function efl_canvas_vg_object_default_size_get was called");
 988             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 989             if (ws != null)
 990             {
 991             Eina.Size2D _ret_var = default(Eina.Size2D);
 992                 try
 993                 {
 994                     _ret_var = ((Object)ws.Target).GetDefaultSize();
 995                 }
 996                 catch (Exception e)
 997                 {
 998                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 999                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1000                 }
1001
1002         return _ret_var;
1003
1004             }
1005             else
1006             {
1007                 return efl_canvas_vg_object_default_size_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
1008             }
1009         }
1010
1011         private static efl_canvas_vg_object_default_size_get_delegate efl_canvas_vg_object_default_size_get_static_delegate;
1012
1013
1014         private delegate Eina.File efl_file_mmap_get_delegate(System.IntPtr obj, System.IntPtr pd);
1015
1016
1017         public delegate Eina.File efl_file_mmap_get_api_delegate(System.IntPtr obj);
1018
1019         public static Efl.Eo.FunctionWrapper<efl_file_mmap_get_api_delegate> efl_file_mmap_get_ptr = new Efl.Eo.FunctionWrapper<efl_file_mmap_get_api_delegate>(Module, "efl_file_mmap_get");
1020
1021         private static Eina.File mmap_get(System.IntPtr obj, System.IntPtr pd)
1022         {
1023             Eina.Log.Debug("function efl_file_mmap_get was called");
1024             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1025             if (ws != null)
1026             {
1027             Eina.File _ret_var = default(Eina.File);
1028                 try
1029                 {
1030                     _ret_var = ((Object)ws.Target).GetMmap();
1031                 }
1032                 catch (Exception e)
1033                 {
1034                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1035                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1036                 }
1037
1038         return _ret_var;
1039
1040             }
1041             else
1042             {
1043                 return efl_file_mmap_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
1044             }
1045         }
1046
1047         private static efl_file_mmap_get_delegate efl_file_mmap_get_static_delegate;
1048
1049
1050         private delegate Eina.Error efl_file_mmap_set_delegate(System.IntPtr obj, System.IntPtr pd,  Eina.File f);
1051
1052
1053         public delegate Eina.Error efl_file_mmap_set_api_delegate(System.IntPtr obj,  Eina.File f);
1054
1055         public static Efl.Eo.FunctionWrapper<efl_file_mmap_set_api_delegate> efl_file_mmap_set_ptr = new Efl.Eo.FunctionWrapper<efl_file_mmap_set_api_delegate>(Module, "efl_file_mmap_set");
1056
1057         private static Eina.Error mmap_set(System.IntPtr obj, System.IntPtr pd, Eina.File f)
1058         {
1059             Eina.Log.Debug("function efl_file_mmap_set was called");
1060             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1061             if (ws != null)
1062             {
1063                                     Eina.Error _ret_var = default(Eina.Error);
1064                 try
1065                 {
1066                     _ret_var = ((Object)ws.Target).SetMmap(f);
1067                 }
1068                 catch (Exception e)
1069                 {
1070                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1071                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1072                 }
1073
1074                         return _ret_var;
1075
1076             }
1077             else
1078             {
1079                 return efl_file_mmap_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), f);
1080             }
1081         }
1082
1083         private static efl_file_mmap_set_delegate efl_file_mmap_set_static_delegate;
1084
1085         [return: MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))]
1086         private delegate System.String efl_file_get_delegate(System.IntPtr obj, System.IntPtr pd);
1087
1088         [return: MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))]
1089         public delegate System.String efl_file_get_api_delegate(System.IntPtr obj);
1090
1091         public static Efl.Eo.FunctionWrapper<efl_file_get_api_delegate> efl_file_get_ptr = new Efl.Eo.FunctionWrapper<efl_file_get_api_delegate>(Module, "efl_file_get");
1092
1093         private static System.String file_get(System.IntPtr obj, System.IntPtr pd)
1094         {
1095             Eina.Log.Debug("function efl_file_get was called");
1096             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1097             if (ws != null)
1098             {
1099             System.String _ret_var = default(System.String);
1100                 try
1101                 {
1102                     _ret_var = ((Object)ws.Target).GetFile();
1103                 }
1104                 catch (Exception e)
1105                 {
1106                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1107                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1108                 }
1109
1110         return _ret_var;
1111
1112             }
1113             else
1114             {
1115                 return efl_file_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
1116             }
1117         }
1118
1119         private static efl_file_get_delegate efl_file_get_static_delegate;
1120
1121
1122         private delegate Eina.Error efl_file_set_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))] System.String file);
1123
1124
1125         public delegate Eina.Error efl_file_set_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))] System.String file);
1126
1127         public static Efl.Eo.FunctionWrapper<efl_file_set_api_delegate> efl_file_set_ptr = new Efl.Eo.FunctionWrapper<efl_file_set_api_delegate>(Module, "efl_file_set");
1128
1129         private static Eina.Error file_set(System.IntPtr obj, System.IntPtr pd, System.String file)
1130         {
1131             Eina.Log.Debug("function efl_file_set was called");
1132             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1133             if (ws != null)
1134             {
1135                                     Eina.Error _ret_var = default(Eina.Error);
1136                 try
1137                 {
1138                     _ret_var = ((Object)ws.Target).SetFile(file);
1139                 }
1140                 catch (Exception e)
1141                 {
1142                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1143                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1144                 }
1145
1146                         return _ret_var;
1147
1148             }
1149             else
1150             {
1151                 return efl_file_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), file);
1152             }
1153         }
1154
1155         private static efl_file_set_delegate efl_file_set_static_delegate;
1156
1157         [return: MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))]
1158         private delegate System.String efl_file_key_get_delegate(System.IntPtr obj, System.IntPtr pd);
1159
1160         [return: MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))]
1161         public delegate System.String efl_file_key_get_api_delegate(System.IntPtr obj);
1162
1163         public static Efl.Eo.FunctionWrapper<efl_file_key_get_api_delegate> efl_file_key_get_ptr = new Efl.Eo.FunctionWrapper<efl_file_key_get_api_delegate>(Module, "efl_file_key_get");
1164
1165         private static System.String key_get(System.IntPtr obj, System.IntPtr pd)
1166         {
1167             Eina.Log.Debug("function efl_file_key_get was called");
1168             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1169             if (ws != null)
1170             {
1171             System.String _ret_var = default(System.String);
1172                 try
1173                 {
1174                     _ret_var = ((Object)ws.Target).GetKey();
1175                 }
1176                 catch (Exception e)
1177                 {
1178                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1179                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1180                 }
1181
1182         return _ret_var;
1183
1184             }
1185             else
1186             {
1187                 return efl_file_key_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
1188             }
1189         }
1190
1191         private static efl_file_key_get_delegate efl_file_key_get_static_delegate;
1192
1193
1194         private delegate void efl_file_key_set_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))] System.String key);
1195
1196
1197         public delegate void efl_file_key_set_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))] System.String key);
1198
1199         public static Efl.Eo.FunctionWrapper<efl_file_key_set_api_delegate> efl_file_key_set_ptr = new Efl.Eo.FunctionWrapper<efl_file_key_set_api_delegate>(Module, "efl_file_key_set");
1200
1201         private static void key_set(System.IntPtr obj, System.IntPtr pd, System.String key)
1202         {
1203             Eina.Log.Debug("function efl_file_key_set was called");
1204             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1205             if (ws != null)
1206             {
1207
1208                 try
1209                 {
1210                     ((Object)ws.Target).SetKey(key);
1211                 }
1212                 catch (Exception e)
1213                 {
1214                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1215                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1216                 }
1217
1218
1219             }
1220             else
1221             {
1222                 efl_file_key_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), key);
1223             }
1224         }
1225
1226         private static efl_file_key_set_delegate efl_file_key_set_static_delegate;
1227
1228         [return: MarshalAs(UnmanagedType.U1)]
1229         private delegate bool efl_file_loaded_get_delegate(System.IntPtr obj, System.IntPtr pd);
1230
1231         [return: MarshalAs(UnmanagedType.U1)]
1232         public delegate bool efl_file_loaded_get_api_delegate(System.IntPtr obj);
1233
1234         public static Efl.Eo.FunctionWrapper<efl_file_loaded_get_api_delegate> efl_file_loaded_get_ptr = new Efl.Eo.FunctionWrapper<efl_file_loaded_get_api_delegate>(Module, "efl_file_loaded_get");
1235
1236         private static bool loaded_get(System.IntPtr obj, System.IntPtr pd)
1237         {
1238             Eina.Log.Debug("function efl_file_loaded_get was called");
1239             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1240             if (ws != null)
1241             {
1242             bool _ret_var = default(bool);
1243                 try
1244                 {
1245                     _ret_var = ((Object)ws.Target).GetLoaded();
1246                 }
1247                 catch (Exception e)
1248                 {
1249                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1250                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1251                 }
1252
1253         return _ret_var;
1254
1255             }
1256             else
1257             {
1258                 return efl_file_loaded_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
1259             }
1260         }
1261
1262         private static efl_file_loaded_get_delegate efl_file_loaded_get_static_delegate;
1263
1264
1265         private delegate Eina.Error efl_file_load_delegate(System.IntPtr obj, System.IntPtr pd);
1266
1267
1268         public delegate Eina.Error efl_file_load_api_delegate(System.IntPtr obj);
1269
1270         public static Efl.Eo.FunctionWrapper<efl_file_load_api_delegate> efl_file_load_ptr = new Efl.Eo.FunctionWrapper<efl_file_load_api_delegate>(Module, "efl_file_load");
1271
1272         private static Eina.Error load(System.IntPtr obj, System.IntPtr pd)
1273         {
1274             Eina.Log.Debug("function efl_file_load was called");
1275             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1276             if (ws != null)
1277             {
1278             Eina.Error _ret_var = default(Eina.Error);
1279                 try
1280                 {
1281                     _ret_var = ((Object)ws.Target).Load();
1282                 }
1283                 catch (Exception e)
1284                 {
1285                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1286                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1287                 }
1288
1289         return _ret_var;
1290
1291             }
1292             else
1293             {
1294                 return efl_file_load_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
1295             }
1296         }
1297
1298         private static efl_file_load_delegate efl_file_load_static_delegate;
1299
1300
1301         private delegate void efl_file_unload_delegate(System.IntPtr obj, System.IntPtr pd);
1302
1303
1304         public delegate void efl_file_unload_api_delegate(System.IntPtr obj);
1305
1306         public static Efl.Eo.FunctionWrapper<efl_file_unload_api_delegate> efl_file_unload_ptr = new Efl.Eo.FunctionWrapper<efl_file_unload_api_delegate>(Module, "efl_file_unload");
1307
1308         private static void unload(System.IntPtr obj, System.IntPtr pd)
1309         {
1310             Eina.Log.Debug("function efl_file_unload was called");
1311             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1312             if (ws != null)
1313             {
1314
1315                 try
1316                 {
1317                     ((Object)ws.Target).Unload();
1318                 }
1319                 catch (Exception e)
1320                 {
1321                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1322                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1323                 }
1324
1325
1326             }
1327             else
1328             {
1329                 efl_file_unload_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
1330             }
1331         }
1332
1333         private static efl_file_unload_delegate efl_file_unload_static_delegate;
1334
1335         [return: MarshalAs(UnmanagedType.U1)]
1336         private delegate bool efl_file_save_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))] System.String file, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))] System.String key,  ref Efl.FileSaveInfo.NativeStruct info);
1337
1338         [return: MarshalAs(UnmanagedType.U1)]
1339         public delegate bool efl_file_save_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))] System.String file, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))] System.String key,  ref Efl.FileSaveInfo.NativeStruct info);
1340
1341         public static Efl.Eo.FunctionWrapper<efl_file_save_api_delegate> efl_file_save_ptr = new Efl.Eo.FunctionWrapper<efl_file_save_api_delegate>(Module, "efl_file_save");
1342
1343         private static bool save(System.IntPtr obj, System.IntPtr pd, System.String file, System.String key, ref Efl.FileSaveInfo.NativeStruct info)
1344         {
1345             Eina.Log.Debug("function efl_file_save was called");
1346             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1347             if (ws != null)
1348             {
1349                         Efl.FileSaveInfo _in_info = info;
1350                                                             bool _ret_var = default(bool);
1351                 try
1352                 {
1353                     _ret_var = ((Object)ws.Target).Save(file, key, ref _in_info);
1354                 }
1355                 catch (Exception e)
1356                 {
1357                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1358                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1359                 }
1360
1361                                                 info = _in_info;
1362         return _ret_var;
1363
1364             }
1365             else
1366             {
1367                 return efl_file_save_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), file, key, ref info);
1368             }
1369         }
1370
1371         private static efl_file_save_delegate efl_file_save_static_delegate;
1372
1373         [return: MarshalAs(UnmanagedType.U1)]
1374         private delegate bool efl_gfx_frame_controller_animated_get_delegate(System.IntPtr obj, System.IntPtr pd);
1375
1376         [return: MarshalAs(UnmanagedType.U1)]
1377         public delegate bool efl_gfx_frame_controller_animated_get_api_delegate(System.IntPtr obj);
1378
1379         public static Efl.Eo.FunctionWrapper<efl_gfx_frame_controller_animated_get_api_delegate> efl_gfx_frame_controller_animated_get_ptr = new Efl.Eo.FunctionWrapper<efl_gfx_frame_controller_animated_get_api_delegate>(Module, "efl_gfx_frame_controller_animated_get");
1380
1381         private static bool animated_get(System.IntPtr obj, System.IntPtr pd)
1382         {
1383             Eina.Log.Debug("function efl_gfx_frame_controller_animated_get was called");
1384             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1385             if (ws != null)
1386             {
1387             bool _ret_var = default(bool);
1388                 try
1389                 {
1390                     _ret_var = ((Object)ws.Target).GetAnimated();
1391                 }
1392                 catch (Exception e)
1393                 {
1394                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1395                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1396                 }
1397
1398         return _ret_var;
1399
1400             }
1401             else
1402             {
1403                 return efl_gfx_frame_controller_animated_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
1404             }
1405         }
1406
1407         private static efl_gfx_frame_controller_animated_get_delegate efl_gfx_frame_controller_animated_get_static_delegate;
1408
1409
1410         private delegate int efl_gfx_frame_controller_frame_get_delegate(System.IntPtr obj, System.IntPtr pd);
1411
1412
1413         public delegate int efl_gfx_frame_controller_frame_get_api_delegate(System.IntPtr obj);
1414
1415         public static Efl.Eo.FunctionWrapper<efl_gfx_frame_controller_frame_get_api_delegate> efl_gfx_frame_controller_frame_get_ptr = new Efl.Eo.FunctionWrapper<efl_gfx_frame_controller_frame_get_api_delegate>(Module, "efl_gfx_frame_controller_frame_get");
1416
1417         private static int frame_get(System.IntPtr obj, System.IntPtr pd)
1418         {
1419             Eina.Log.Debug("function efl_gfx_frame_controller_frame_get was called");
1420             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1421             if (ws != null)
1422             {
1423             int _ret_var = default(int);
1424                 try
1425                 {
1426                     _ret_var = ((Object)ws.Target).GetFrame();
1427                 }
1428                 catch (Exception e)
1429                 {
1430                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1431                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1432                 }
1433
1434         return _ret_var;
1435
1436             }
1437             else
1438             {
1439                 return efl_gfx_frame_controller_frame_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
1440             }
1441         }
1442
1443         private static efl_gfx_frame_controller_frame_get_delegate efl_gfx_frame_controller_frame_get_static_delegate;
1444
1445         [return: MarshalAs(UnmanagedType.U1)]
1446         private delegate bool efl_gfx_frame_controller_frame_set_delegate(System.IntPtr obj, System.IntPtr pd,  int frame_index);
1447
1448         [return: MarshalAs(UnmanagedType.U1)]
1449         public delegate bool efl_gfx_frame_controller_frame_set_api_delegate(System.IntPtr obj,  int frame_index);
1450
1451         public static Efl.Eo.FunctionWrapper<efl_gfx_frame_controller_frame_set_api_delegate> efl_gfx_frame_controller_frame_set_ptr = new Efl.Eo.FunctionWrapper<efl_gfx_frame_controller_frame_set_api_delegate>(Module, "efl_gfx_frame_controller_frame_set");
1452
1453         private static bool frame_set(System.IntPtr obj, System.IntPtr pd, int frame_index)
1454         {
1455             Eina.Log.Debug("function efl_gfx_frame_controller_frame_set was called");
1456             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1457             if (ws != null)
1458             {
1459                                     bool _ret_var = default(bool);
1460                 try
1461                 {
1462                     _ret_var = ((Object)ws.Target).SetFrame(frame_index);
1463                 }
1464                 catch (Exception e)
1465                 {
1466                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1467                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1468                 }
1469
1470                         return _ret_var;
1471
1472             }
1473             else
1474             {
1475                 return efl_gfx_frame_controller_frame_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), frame_index);
1476             }
1477         }
1478
1479         private static efl_gfx_frame_controller_frame_set_delegate efl_gfx_frame_controller_frame_set_static_delegate;
1480
1481
1482         private delegate int efl_gfx_frame_controller_frame_count_get_delegate(System.IntPtr obj, System.IntPtr pd);
1483
1484
1485         public delegate int efl_gfx_frame_controller_frame_count_get_api_delegate(System.IntPtr obj);
1486
1487         public static Efl.Eo.FunctionWrapper<efl_gfx_frame_controller_frame_count_get_api_delegate> efl_gfx_frame_controller_frame_count_get_ptr = new Efl.Eo.FunctionWrapper<efl_gfx_frame_controller_frame_count_get_api_delegate>(Module, "efl_gfx_frame_controller_frame_count_get");
1488
1489         private static int frame_count_get(System.IntPtr obj, System.IntPtr pd)
1490         {
1491             Eina.Log.Debug("function efl_gfx_frame_controller_frame_count_get was called");
1492             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1493             if (ws != null)
1494             {
1495             int _ret_var = default(int);
1496                 try
1497                 {
1498                     _ret_var = ((Object)ws.Target).GetFrameCount();
1499                 }
1500                 catch (Exception e)
1501                 {
1502                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1503                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1504                 }
1505
1506         return _ret_var;
1507
1508             }
1509             else
1510             {
1511                 return efl_gfx_frame_controller_frame_count_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
1512             }
1513         }
1514
1515         private static efl_gfx_frame_controller_frame_count_get_delegate efl_gfx_frame_controller_frame_count_get_static_delegate;
1516
1517
1518         private delegate Efl.Gfx.FrameControllerLoopHint efl_gfx_frame_controller_loop_type_get_delegate(System.IntPtr obj, System.IntPtr pd);
1519
1520
1521         public delegate Efl.Gfx.FrameControllerLoopHint efl_gfx_frame_controller_loop_type_get_api_delegate(System.IntPtr obj);
1522
1523         public static Efl.Eo.FunctionWrapper<efl_gfx_frame_controller_loop_type_get_api_delegate> efl_gfx_frame_controller_loop_type_get_ptr = new Efl.Eo.FunctionWrapper<efl_gfx_frame_controller_loop_type_get_api_delegate>(Module, "efl_gfx_frame_controller_loop_type_get");
1524
1525         private static Efl.Gfx.FrameControllerLoopHint loop_type_get(System.IntPtr obj, System.IntPtr pd)
1526         {
1527             Eina.Log.Debug("function efl_gfx_frame_controller_loop_type_get was called");
1528             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1529             if (ws != null)
1530             {
1531             Efl.Gfx.FrameControllerLoopHint _ret_var = default(Efl.Gfx.FrameControllerLoopHint);
1532                 try
1533                 {
1534                     _ret_var = ((Object)ws.Target).GetLoopType();
1535                 }
1536                 catch (Exception e)
1537                 {
1538                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1539                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1540                 }
1541
1542         return _ret_var;
1543
1544             }
1545             else
1546             {
1547                 return efl_gfx_frame_controller_loop_type_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
1548             }
1549         }
1550
1551         private static efl_gfx_frame_controller_loop_type_get_delegate efl_gfx_frame_controller_loop_type_get_static_delegate;
1552
1553
1554         private delegate int efl_gfx_frame_controller_loop_count_get_delegate(System.IntPtr obj, System.IntPtr pd);
1555
1556
1557         public delegate int efl_gfx_frame_controller_loop_count_get_api_delegate(System.IntPtr obj);
1558
1559         public static Efl.Eo.FunctionWrapper<efl_gfx_frame_controller_loop_count_get_api_delegate> efl_gfx_frame_controller_loop_count_get_ptr = new Efl.Eo.FunctionWrapper<efl_gfx_frame_controller_loop_count_get_api_delegate>(Module, "efl_gfx_frame_controller_loop_count_get");
1560
1561         private static int loop_count_get(System.IntPtr obj, System.IntPtr pd)
1562         {
1563             Eina.Log.Debug("function efl_gfx_frame_controller_loop_count_get was called");
1564             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1565             if (ws != null)
1566             {
1567             int _ret_var = default(int);
1568                 try
1569                 {
1570                     _ret_var = ((Object)ws.Target).GetLoopCount();
1571                 }
1572                 catch (Exception e)
1573                 {
1574                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1575                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1576                 }
1577
1578         return _ret_var;
1579
1580             }
1581             else
1582             {
1583                 return efl_gfx_frame_controller_loop_count_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
1584             }
1585         }
1586
1587         private static efl_gfx_frame_controller_loop_count_get_delegate efl_gfx_frame_controller_loop_count_get_static_delegate;
1588
1589
1590         private delegate double efl_gfx_frame_controller_frame_duration_get_delegate(System.IntPtr obj, System.IntPtr pd,  int start_frame,  int frame_num);
1591
1592
1593         public delegate double efl_gfx_frame_controller_frame_duration_get_api_delegate(System.IntPtr obj,  int start_frame,  int frame_num);
1594
1595         public static Efl.Eo.FunctionWrapper<efl_gfx_frame_controller_frame_duration_get_api_delegate> efl_gfx_frame_controller_frame_duration_get_ptr = new Efl.Eo.FunctionWrapper<efl_gfx_frame_controller_frame_duration_get_api_delegate>(Module, "efl_gfx_frame_controller_frame_duration_get");
1596
1597         private static double frame_duration_get(System.IntPtr obj, System.IntPtr pd, int start_frame, int frame_num)
1598         {
1599             Eina.Log.Debug("function efl_gfx_frame_controller_frame_duration_get was called");
1600             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1601             if (ws != null)
1602             {
1603                                                             double _ret_var = default(double);
1604                 try
1605                 {
1606                     _ret_var = ((Object)ws.Target).GetFrameDuration(start_frame, frame_num);
1607                 }
1608                 catch (Exception e)
1609                 {
1610                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1611                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1612                 }
1613
1614                                         return _ret_var;
1615
1616             }
1617             else
1618             {
1619                 return efl_gfx_frame_controller_frame_duration_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), start_frame, frame_num);
1620             }
1621         }
1622
1623         private static efl_gfx_frame_controller_frame_duration_get_delegate efl_gfx_frame_controller_frame_duration_get_static_delegate;
1624
1625         #pragma warning restore CA1707, CS1591, SA1300, SA1600
1626
1627 }
1628 }
1629 }
1630
1631 }
1632
1633 }
1634
1635 #if EFL_BETA
1636 #pragma warning disable CS1591
1637 public static class Efl_Canvas_VgObject_ExtensionMethods {
1638     public static Efl.BindableProperty<Efl.Canvas.Vg.FillMode> FillMode<T>(this Efl.Ui.ItemFactory<T> fac, Efl.Csharp.ExtensionTag<Efl.Canvas.Vg.Object, T>magic = null) where T : Efl.Canvas.Vg.Object {
1639         return new Efl.BindableProperty<Efl.Canvas.Vg.FillMode>("fill_mode", fac);
1640     }
1641
1642     public static Efl.BindableProperty<Eina.Rect> Viewbox<T>(this Efl.Ui.ItemFactory<T> fac, Efl.Csharp.ExtensionTag<Efl.Canvas.Vg.Object, T>magic = null) where T : Efl.Canvas.Vg.Object {
1643         return new Efl.BindableProperty<Eina.Rect>("viewbox", fac);
1644     }
1645
1646
1647     public static Efl.BindableProperty<Efl.Canvas.Vg.Node> RootNode<T>(this Efl.Ui.ItemFactory<T> fac, Efl.Csharp.ExtensionTag<Efl.Canvas.Vg.Object, T>magic = null) where T : Efl.Canvas.Vg.Object {
1648         return new Efl.BindableProperty<Efl.Canvas.Vg.Node>("root_node", fac);
1649     }
1650
1651
1652     public static Efl.BindableProperty<Eina.File> Mmap<T>(this Efl.Ui.ItemFactory<T> fac, Efl.Csharp.ExtensionTag<Efl.Canvas.Vg.Object, T>magic = null) where T : Efl.Canvas.Vg.Object {
1653         return new Efl.BindableProperty<Eina.File>("mmap", fac);
1654     }
1655
1656     public static Efl.BindableProperty<System.String> File<T>(this Efl.Ui.ItemFactory<T> fac, Efl.Csharp.ExtensionTag<Efl.Canvas.Vg.Object, T>magic = null) where T : Efl.Canvas.Vg.Object {
1657         return new Efl.BindableProperty<System.String>("file", fac);
1658     }
1659
1660     public static Efl.BindableProperty<System.String> Key<T>(this Efl.Ui.ItemFactory<T> fac, Efl.Csharp.ExtensionTag<Efl.Canvas.Vg.Object, T>magic = null) where T : Efl.Canvas.Vg.Object {
1661         return new Efl.BindableProperty<System.String>("key", fac);
1662     }
1663
1664
1665
1666     public static Efl.BindableProperty<int> Frame<T>(this Efl.Ui.ItemFactory<T> fac, Efl.Csharp.ExtensionTag<Efl.Canvas.Vg.Object, T>magic = null) where T : Efl.Canvas.Vg.Object {
1667         return new Efl.BindableProperty<int>("frame", fac);
1668     }
1669
1670
1671
1672
1673
1674 }
1675 #pragma warning restore CS1591
1676 #endif
1677 namespace Efl {
1678
1679 namespace Canvas {
1680
1681 namespace Vg {
1682
1683 /// <summary>Enumeration that defines how viewbox will be filled int the vg canvs&apos;s viewport. default Fill_Mode is <c>none</c></summary>
1684 [Efl.Eo.BindingEntity]
1685 public enum FillMode
1686 {
1687 /// <summary>Don&apos;t scale the viewbox. Placed it inside viewport taking align property into account</summary>
1688 None = 0,
1689 /// <summary>Scale the viewbox so that it matches the canvas viewport. Aaspect ratio might be changed.</summary>
1690 Stretch = 1,
1691 /// <summary>Scale the viewbox so that it fits inside canvas viewport while maintaining the aspect ratio. At least one of the dimensions of the viewbox should be equal to the corresponding dimension of the viewport.</summary>
1692 Meet = 2,
1693 /// <summary>Scale the viewbox so that it covers the entire canvas viewport while maintaining the aspect ratio. At least one of the dimensions of the viewbox should be equal to the corresponding dimension of the viewport.</summary>
1694 Slice = 3,
1695 }
1696
1697 }
1698
1699 }
1700
1701 }
1702