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

   1 #pragma warning disable CS1591
   2 using System;
   3 using System.Runtime.InteropServices;
   4 using System.Collections.Generic;
   5 using System.Linq;
   6 using System.ComponentModel;
   7 namespace Efl { namespace Ui {
   8 /// <summary>Common interface for draggable objects and parts.</summary>
   9 [IDragNativeInherit]
  10 public interface IDrag :
  11     Efl.Eo.IWrapper, IDisposable
  12 {
  13     /// <summary>Gets the draggable object location.</summary>
  14 /// <param name="dx">The x relative position, from 0 to 1.</param>
  15 /// <param name="dy">The y relative position, from 0 to 1.</param>
  16 /// <returns><c>true</c> on success, <c>false</c> otherwise</returns>
  17 bool GetDragValue( out double dx,  out double dy);
  18     /// <summary>Sets the draggable object location.
  19 /// This places the draggable object at the given location.</summary>
  20 /// <param name="dx">The x relative position, from 0 to 1.</param>
  21 /// <param name="dy">The y relative position, from 0 to 1.</param>
  22 /// <returns><c>true</c> on success, <c>false</c> otherwise</returns>
  23 bool SetDragValue( double dx,  double dy);
  24     /// <summary>Gets the size of the dradgable object.</summary>
  25 /// <param name="dw">The drag relative width, from 0 to 1.</param>
  26 /// <param name="dh">The drag relative height, from 0 to 1.</param>
  27 /// <returns><c>true</c> on success, <c>false</c> otherwise</returns>
  28 bool GetDragSize( out double dw,  out double dh);
  29     /// <summary>Sets the size of the draggable object.</summary>
  30 /// <param name="dw">The drag relative width, from 0 to 1.</param>
  31 /// <param name="dh">The drag relative height, from 0 to 1.</param>
  32 /// <returns><c>true</c> on success, <c>false</c> otherwise</returns>
  33 bool SetDragSize( double dw,  double dh);
  34     /// <summary>Gets the draggable direction.</summary>
  35 /// <returns>The direction(s) premitted for drag.</returns>
  36 Efl.Ui.DragDir GetDragDir();
  37     /// <summary>Gets the x and y step increments for the draggable object.</summary>
  38 /// <param name="dx">The x step relative amount, from 0 to 1.</param>
  39 /// <param name="dy">The y step relative amount, from 0 to 1.</param>
  40 /// <returns><c>true</c> on success, <c>false</c> otherwise</returns>
  41 bool GetDragStep( out double dx,  out double dy);
  42     /// <summary>Sets the x,y step increments for a draggable object.</summary>
  43 /// <param name="dx">The x step relative amount, from 0 to 1.</param>
  44 /// <param name="dy">The y step relative amount, from 0 to 1.</param>
  45 /// <returns><c>true</c> on success, <c>false</c> otherwise</returns>
  46 bool SetDragStep( double dx,  double dy);
  47     /// <summary>Gets the x,y page step increments for the draggable object.</summary>
  48 /// <param name="dx">The x page step increment</param>
  49 /// <param name="dy">The y page step increment</param>
  50 /// <returns><c>true</c> on success, <c>false</c> otherwise</returns>
  51 bool GetDragPage( out double dx,  out double dy);
  52     /// <summary>Sets the x,y page step increment values.</summary>
  53 /// <param name="dx">The x page step increment</param>
  54 /// <param name="dy">The y page step increment</param>
  55 /// <returns><c>true</c> on success, <c>false</c> otherwise</returns>
  56 bool SetDragPage( double dx,  double dy);
  57     /// <summary>Moves the draggable by <c>dx</c>,<c>dy</c> steps.
  58 /// This moves the draggable part by <c>dx</c>,<c>dy</c> steps where the step increment is the amount set by <see cref="Efl.Ui.IDrag.GetDragStep"/>.
  59 ///
  60 /// <c>dx</c> and <c>dy</c> can be positive or negative numbers, integer values are recommended.</summary>
  61 /// <param name="dx">The number of steps horizontally.</param>
  62 /// <param name="dy">The number of steps vertically.</param>
  63 /// <returns><c>true</c> on success, <c>false</c> otherwise</returns>
  64 bool MoveDragStep( double dx,  double dy);
  65     /// <summary>Moves the draggable by <c>dx</c>,<c>dy</c> pages.
  66 /// This moves the draggable by <c>dx</c>,<c>dy</c> pages. The increment is defined by <see cref="Efl.Ui.IDrag.GetDragPage"/>.
  67 ///
  68 /// <c>dx</c> and <c>dy</c> can be positive or negative numbers, integer values are recommended.
  69 ///
  70 /// Warning: Paging is bugged!</summary>
  71 /// <param name="dx">The number of pages horizontally.</param>
  72 /// <param name="dy">The number of pages vertically.</param>
  73 /// <returns><c>true</c> on success, <c>false</c> otherwise</returns>
  74 bool MoveDragPage( double dx,  double dy);
  75                                                 /// <summary>Determines the draggable directions (read-only).
  76 /// The draggable directions are defined in the EDC file, inside the &quot;draggable&quot; section, by the attributes <c>x</c> and <c>y</c>. See the EDC reference documentation for more information.</summary>
  77 /// <value>The direction(s) premitted for drag.</value>
  78     Efl.Ui.DragDir DragDir {
  79         get ;
  80     }
  81 }
  82 /// <summary>Common interface for draggable objects and parts.</summary>
  83 sealed public class IDragConcrete :
  84
  85 IDrag
  86
  87 {
  88     ///<summary>Pointer to the native class description.</summary>
  89     public System.IntPtr NativeClass {
  90         get {
  91             if (((object)this).GetType() == typeof (IDragConcrete))
  92                 return Efl.Ui.IDragNativeInherit.GetEflClassStatic();
  93             else
  94                 return Efl.Eo.ClassRegister.klassFromType[((object)this).GetType()];
  95         }
  96     }
  97     private  System.IntPtr handle;
  98     ///<summary>Pointer to the native instance.</summary>
  99     public System.IntPtr NativeHandle {
 100         get { return handle; }
 101     }
 102     [System.Runtime.InteropServices.DllImport(efl.Libs.Efl)] internal static extern System.IntPtr
 103         efl_ui_drag_interface_get();
 104     ///<summary>Internal usage: Constructs an instance from a native pointer. This is used when interacting with C code and should not be used directly.</summary>
 105     private IDragConcrete(System.IntPtr raw)
 106     {
 107         handle = raw;
 108         RegisterEventProxies();
 109     }
 110     ///<summary>Destructor.</summary>
 111     ~IDragConcrete()
 112     {
 113         Dispose(false);
 114     }
 115     ///<summary>Releases the underlying native instance.</summary>
 116     void Dispose(bool disposing)
 117     {
 118         if (handle != System.IntPtr.Zero) {
 119             Efl.Eo.Globals.efl_unref(handle);
 120             handle = System.IntPtr.Zero;
 121         }
 122     }
 123     ///<summary>Releases the underlying native instance.</summary>
 124     public void Dispose()
 125     {
 126         Dispose(true);
 127         GC.SuppressFinalize(this);
 128     }
 129     ///<summary>Verifies if the given object is equal to this one.</summary>
 130     public override bool Equals(object obj)
 131     {
 132         var other = obj as Efl.Object;
 133         if (other == null)
 134             return false;
 135         return this.NativeHandle == other.NativeHandle;
 136     }
 137     ///<summary>Gets the hash code for this object based on the native pointer it points to.</summary>
 138     public override int GetHashCode()
 139     {
 140         return this.NativeHandle.ToInt32();
 141     }
 142     ///<summary>Turns the native pointer into a string representation.</summary>
 143     public override String ToString()
 144     {
 145         return $"{this.GetType().Name}@[{this.NativeHandle.ToInt32():x}]";
 146     }
 147     ///<summary>Register the Eo event wrappers making the bridge to C# events. Internal usage only.</summary>
 148      void RegisterEventProxies()
 149     {
 150     }
 151     /// <summary>Gets the draggable object location.</summary>
 152     /// <param name="dx">The x relative position, from 0 to 1.</param>
 153     /// <param name="dy">The y relative position, from 0 to 1.</param>
 154     /// <returns><c>true</c> on success, <c>false</c> otherwise</returns>
 155     public bool GetDragValue( out double dx,  out double dy) {
 156                                                          var _ret_var = Efl.Ui.IDragNativeInherit.efl_ui_drag_value_get_ptr.Value.Delegate(this.NativeHandle, out dx,  out dy);
 157         Eina.Error.RaiseIfUnhandledException();
 158                                         return _ret_var;
 159  }
 160     /// <summary>Sets the draggable object location.
 161     /// This places the draggable object at the given location.</summary>
 162     /// <param name="dx">The x relative position, from 0 to 1.</param>
 163     /// <param name="dy">The y relative position, from 0 to 1.</param>
 164     /// <returns><c>true</c> on success, <c>false</c> otherwise</returns>
 165     public bool SetDragValue( double dx,  double dy) {
 166                                                          var _ret_var = Efl.Ui.IDragNativeInherit.efl_ui_drag_value_set_ptr.Value.Delegate(this.NativeHandle, dx,  dy);
 167         Eina.Error.RaiseIfUnhandledException();
 168                                         return _ret_var;
 169  }
 170     /// <summary>Gets the size of the dradgable object.</summary>
 171     /// <param name="dw">The drag relative width, from 0 to 1.</param>
 172     /// <param name="dh">The drag relative height, from 0 to 1.</param>
 173     /// <returns><c>true</c> on success, <c>false</c> otherwise</returns>
 174     public bool GetDragSize( out double dw,  out double dh) {
 175                                                          var _ret_var = Efl.Ui.IDragNativeInherit.efl_ui_drag_size_get_ptr.Value.Delegate(this.NativeHandle, out dw,  out dh);
 176         Eina.Error.RaiseIfUnhandledException();
 177                                         return _ret_var;
 178  }
 179     /// <summary>Sets the size of the draggable object.</summary>
 180     /// <param name="dw">The drag relative width, from 0 to 1.</param>
 181     /// <param name="dh">The drag relative height, from 0 to 1.</param>
 182     /// <returns><c>true</c> on success, <c>false</c> otherwise</returns>
 183     public bool SetDragSize( double dw,  double dh) {
 184                                                          var _ret_var = Efl.Ui.IDragNativeInherit.efl_ui_drag_size_set_ptr.Value.Delegate(this.NativeHandle, dw,  dh);
 185         Eina.Error.RaiseIfUnhandledException();
 186                                         return _ret_var;
 187  }
 188     /// <summary>Gets the draggable direction.</summary>
 189     /// <returns>The direction(s) premitted for drag.</returns>
 190     public Efl.Ui.DragDir GetDragDir() {
 191          var _ret_var = Efl.Ui.IDragNativeInherit.efl_ui_drag_dir_get_ptr.Value.Delegate(this.NativeHandle);
 192         Eina.Error.RaiseIfUnhandledException();
 193         return _ret_var;
 194  }
 195     /// <summary>Gets the x and y step increments for the draggable object.</summary>
 196     /// <param name="dx">The x step relative amount, from 0 to 1.</param>
 197     /// <param name="dy">The y step relative amount, from 0 to 1.</param>
 198     /// <returns><c>true</c> on success, <c>false</c> otherwise</returns>
 199     public bool GetDragStep( out double dx,  out double dy) {
 200                                                          var _ret_var = Efl.Ui.IDragNativeInherit.efl_ui_drag_step_get_ptr.Value.Delegate(this.NativeHandle, out dx,  out dy);
 201         Eina.Error.RaiseIfUnhandledException();
 202                                         return _ret_var;
 203  }
 204     /// <summary>Sets the x,y step increments for a draggable object.</summary>
 205     /// <param name="dx">The x step relative amount, from 0 to 1.</param>
 206     /// <param name="dy">The y step relative amount, from 0 to 1.</param>
 207     /// <returns><c>true</c> on success, <c>false</c> otherwise</returns>
 208     public bool SetDragStep( double dx,  double dy) {
 209                                                          var _ret_var = Efl.Ui.IDragNativeInherit.efl_ui_drag_step_set_ptr.Value.Delegate(this.NativeHandle, dx,  dy);
 210         Eina.Error.RaiseIfUnhandledException();
 211                                         return _ret_var;
 212  }
 213     /// <summary>Gets the x,y page step increments for the draggable object.</summary>
 214     /// <param name="dx">The x page step increment</param>
 215     /// <param name="dy">The y page step increment</param>
 216     /// <returns><c>true</c> on success, <c>false</c> otherwise</returns>
 217     public bool GetDragPage( out double dx,  out double dy) {
 218                                                          var _ret_var = Efl.Ui.IDragNativeInherit.efl_ui_drag_page_get_ptr.Value.Delegate(this.NativeHandle, out dx,  out dy);
 219         Eina.Error.RaiseIfUnhandledException();
 220                                         return _ret_var;
 221  }
 222     /// <summary>Sets the x,y page step increment values.</summary>
 223     /// <param name="dx">The x page step increment</param>
 224     /// <param name="dy">The y page step increment</param>
 225     /// <returns><c>true</c> on success, <c>false</c> otherwise</returns>
 226     public bool SetDragPage( double dx,  double dy) {
 227                                                          var _ret_var = Efl.Ui.IDragNativeInherit.efl_ui_drag_page_set_ptr.Value.Delegate(this.NativeHandle, dx,  dy);
 228         Eina.Error.RaiseIfUnhandledException();
 229                                         return _ret_var;
 230  }
 231     /// <summary>Moves the draggable by <c>dx</c>,<c>dy</c> steps.
 232     /// This moves the draggable part by <c>dx</c>,<c>dy</c> steps where the step increment is the amount set by <see cref="Efl.Ui.IDrag.GetDragStep"/>.
 233     ///
 234     /// <c>dx</c> and <c>dy</c> can be positive or negative numbers, integer values are recommended.</summary>
 235     /// <param name="dx">The number of steps horizontally.</param>
 236     /// <param name="dy">The number of steps vertically.</param>
 237     /// <returns><c>true</c> on success, <c>false</c> otherwise</returns>
 238     public bool MoveDragStep( double dx,  double dy) {
 239                                                          var _ret_var = Efl.Ui.IDragNativeInherit.efl_ui_drag_step_move_ptr.Value.Delegate(this.NativeHandle, dx,  dy);
 240         Eina.Error.RaiseIfUnhandledException();
 241                                         return _ret_var;
 242  }
 243     /// <summary>Moves the draggable by <c>dx</c>,<c>dy</c> pages.
 244     /// This moves the draggable by <c>dx</c>,<c>dy</c> pages. The increment is defined by <see cref="Efl.Ui.IDrag.GetDragPage"/>.
 245     ///
 246     /// <c>dx</c> and <c>dy</c> can be positive or negative numbers, integer values are recommended.
 247     ///
 248     /// Warning: Paging is bugged!</summary>
 249     /// <param name="dx">The number of pages horizontally.</param>
 250     /// <param name="dy">The number of pages vertically.</param>
 251     /// <returns><c>true</c> on success, <c>false</c> otherwise</returns>
 252     public bool MoveDragPage( double dx,  double dy) {
 253                                                          var _ret_var = Efl.Ui.IDragNativeInherit.efl_ui_drag_page_move_ptr.Value.Delegate(this.NativeHandle, dx,  dy);
 254         Eina.Error.RaiseIfUnhandledException();
 255                                         return _ret_var;
 256  }
 257     /// <summary>Determines the draggable directions (read-only).
 258 /// The draggable directions are defined in the EDC file, inside the &quot;draggable&quot; section, by the attributes <c>x</c> and <c>y</c>. See the EDC reference documentation for more information.</summary>
 259 /// <value>The direction(s) premitted for drag.</value>
 260     public Efl.Ui.DragDir DragDir {
 261         get { return GetDragDir(); }
 262     }
 263     private static IntPtr GetEflClassStatic()
 264     {
 265         return Efl.Ui.IDragConcrete.efl_ui_drag_interface_get();
 266     }
 267 }
 268 public class IDragNativeInherit  : Efl.Eo.NativeClass{
 269     public  static Efl.Eo.NativeModule _Module = new Efl.Eo.NativeModule(efl.Libs.Efl);
 270     public override System.Collections.Generic.List<Efl_Op_Description> GetEoOps(System.Type type)
 271     {
 272         var descs = new System.Collections.Generic.List<Efl_Op_Description>();
 273         var methods = Efl.Eo.Globals.GetUserMethods(type);
 274         if (efl_ui_drag_value_get_static_delegate == null)
 275             efl_ui_drag_value_get_static_delegate = new efl_ui_drag_value_get_delegate(drag_value_get);
 276         if (methods.FirstOrDefault(m => m.Name == "GetDragValue") != null)
 277             descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_ui_drag_value_get"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_drag_value_get_static_delegate)});
 278         if (efl_ui_drag_value_set_static_delegate == null)
 279             efl_ui_drag_value_set_static_delegate = new efl_ui_drag_value_set_delegate(drag_value_set);
 280         if (methods.FirstOrDefault(m => m.Name == "SetDragValue") != null)
 281             descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_ui_drag_value_set"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_drag_value_set_static_delegate)});
 282         if (efl_ui_drag_size_get_static_delegate == null)
 283             efl_ui_drag_size_get_static_delegate = new efl_ui_drag_size_get_delegate(drag_size_get);
 284         if (methods.FirstOrDefault(m => m.Name == "GetDragSize") != null)
 285             descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_ui_drag_size_get"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_drag_size_get_static_delegate)});
 286         if (efl_ui_drag_size_set_static_delegate == null)
 287             efl_ui_drag_size_set_static_delegate = new efl_ui_drag_size_set_delegate(drag_size_set);
 288         if (methods.FirstOrDefault(m => m.Name == "SetDragSize") != null)
 289             descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_ui_drag_size_set"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_drag_size_set_static_delegate)});
 290         if (efl_ui_drag_dir_get_static_delegate == null)
 291             efl_ui_drag_dir_get_static_delegate = new efl_ui_drag_dir_get_delegate(drag_dir_get);
 292         if (methods.FirstOrDefault(m => m.Name == "GetDragDir") != null)
 293             descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_ui_drag_dir_get"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_drag_dir_get_static_delegate)});
 294         if (efl_ui_drag_step_get_static_delegate == null)
 295             efl_ui_drag_step_get_static_delegate = new efl_ui_drag_step_get_delegate(drag_step_get);
 296         if (methods.FirstOrDefault(m => m.Name == "GetDragStep") != null)
 297             descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_ui_drag_step_get"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_drag_step_get_static_delegate)});
 298         if (efl_ui_drag_step_set_static_delegate == null)
 299             efl_ui_drag_step_set_static_delegate = new efl_ui_drag_step_set_delegate(drag_step_set);
 300         if (methods.FirstOrDefault(m => m.Name == "SetDragStep") != null)
 301             descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_ui_drag_step_set"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_drag_step_set_static_delegate)});
 302         if (efl_ui_drag_page_get_static_delegate == null)
 303             efl_ui_drag_page_get_static_delegate = new efl_ui_drag_page_get_delegate(drag_page_get);
 304         if (methods.FirstOrDefault(m => m.Name == "GetDragPage") != null)
 305             descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_ui_drag_page_get"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_drag_page_get_static_delegate)});
 306         if (efl_ui_drag_page_set_static_delegate == null)
 307             efl_ui_drag_page_set_static_delegate = new efl_ui_drag_page_set_delegate(drag_page_set);
 308         if (methods.FirstOrDefault(m => m.Name == "SetDragPage") != null)
 309             descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_ui_drag_page_set"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_drag_page_set_static_delegate)});
 310         if (efl_ui_drag_step_move_static_delegate == null)
 311             efl_ui_drag_step_move_static_delegate = new efl_ui_drag_step_move_delegate(drag_step_move);
 312         if (methods.FirstOrDefault(m => m.Name == "MoveDragStep") != null)
 313             descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_ui_drag_step_move"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_drag_step_move_static_delegate)});
 314         if (efl_ui_drag_page_move_static_delegate == null)
 315             efl_ui_drag_page_move_static_delegate = new efl_ui_drag_page_move_delegate(drag_page_move);
 316         if (methods.FirstOrDefault(m => m.Name == "MoveDragPage") != null)
 317             descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_ui_drag_page_move"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_drag_page_move_static_delegate)});
 318         return descs;
 319     }
 320     public override IntPtr GetEflClass()
 321     {
 322         return Efl.Ui.IDragConcrete.efl_ui_drag_interface_get();
 323     }
 324     public static  IntPtr GetEflClassStatic()
 325     {
 326         return Efl.Ui.IDragConcrete.efl_ui_drag_interface_get();
 327     }
 328
 329
 330      [return: MarshalAs(UnmanagedType.U1)] private delegate bool efl_ui_drag_value_get_delegate(System.IntPtr obj, System.IntPtr pd,   out double dx,   out double dy);
 331
 332
 333      [return: MarshalAs(UnmanagedType.U1)] public delegate bool efl_ui_drag_value_get_api_delegate(System.IntPtr obj,   out double dx,   out double dy);
 334      public static Efl.Eo.FunctionWrapper<efl_ui_drag_value_get_api_delegate> efl_ui_drag_value_get_ptr = new Efl.Eo.FunctionWrapper<efl_ui_drag_value_get_api_delegate>(_Module, "efl_ui_drag_value_get");
 335      private static bool drag_value_get(System.IntPtr obj, System.IntPtr pd,  out double dx,  out double dy)
 336     {
 337         Eina.Log.Debug("function efl_ui_drag_value_get was called");
 338         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
 339         if(wrapper != null) {
 340                                     dx = default(double);        dy = default(double);                            bool _ret_var = default(bool);
 341             try {
 342                 _ret_var = ((IDrag)wrapper).GetDragValue( out dx,  out dy);
 343             } catch (Exception e) {
 344                 Eina.Log.Warning($"Callback error: {e.ToString()}");
 345                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 346             }
 347                                         return _ret_var;
 348         } else {
 349             return efl_ui_drag_value_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  out dx,  out dy);
 350         }
 351     }
 352     private static efl_ui_drag_value_get_delegate efl_ui_drag_value_get_static_delegate;
 353
 354
 355      [return: MarshalAs(UnmanagedType.U1)] private delegate bool efl_ui_drag_value_set_delegate(System.IntPtr obj, System.IntPtr pd,   double dx,   double dy);
 356
 357
 358      [return: MarshalAs(UnmanagedType.U1)] public delegate bool efl_ui_drag_value_set_api_delegate(System.IntPtr obj,   double dx,   double dy);
 359      public static Efl.Eo.FunctionWrapper<efl_ui_drag_value_set_api_delegate> efl_ui_drag_value_set_ptr = new Efl.Eo.FunctionWrapper<efl_ui_drag_value_set_api_delegate>(_Module, "efl_ui_drag_value_set");
 360      private static bool drag_value_set(System.IntPtr obj, System.IntPtr pd,  double dx,  double dy)
 361     {
 362         Eina.Log.Debug("function efl_ui_drag_value_set was called");
 363         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
 364         if(wrapper != null) {
 365                                                                         bool _ret_var = default(bool);
 366             try {
 367                 _ret_var = ((IDrag)wrapper).SetDragValue( dx,  dy);
 368             } catch (Exception e) {
 369                 Eina.Log.Warning($"Callback error: {e.ToString()}");
 370                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 371             }
 372                                         return _ret_var;
 373         } else {
 374             return efl_ui_drag_value_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  dx,  dy);
 375         }
 376     }
 377     private static efl_ui_drag_value_set_delegate efl_ui_drag_value_set_static_delegate;
 378
 379
 380      [return: MarshalAs(UnmanagedType.U1)] private delegate bool efl_ui_drag_size_get_delegate(System.IntPtr obj, System.IntPtr pd,   out double dw,   out double dh);
 381
 382
 383      [return: MarshalAs(UnmanagedType.U1)] public delegate bool efl_ui_drag_size_get_api_delegate(System.IntPtr obj,   out double dw,   out double dh);
 384      public static Efl.Eo.FunctionWrapper<efl_ui_drag_size_get_api_delegate> efl_ui_drag_size_get_ptr = new Efl.Eo.FunctionWrapper<efl_ui_drag_size_get_api_delegate>(_Module, "efl_ui_drag_size_get");
 385      private static bool drag_size_get(System.IntPtr obj, System.IntPtr pd,  out double dw,  out double dh)
 386     {
 387         Eina.Log.Debug("function efl_ui_drag_size_get was called");
 388         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
 389         if(wrapper != null) {
 390                                     dw = default(double);        dh = default(double);                            bool _ret_var = default(bool);
 391             try {
 392                 _ret_var = ((IDrag)wrapper).GetDragSize( out dw,  out dh);
 393             } catch (Exception e) {
 394                 Eina.Log.Warning($"Callback error: {e.ToString()}");
 395                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 396             }
 397                                         return _ret_var;
 398         } else {
 399             return efl_ui_drag_size_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  out dw,  out dh);
 400         }
 401     }
 402     private static efl_ui_drag_size_get_delegate efl_ui_drag_size_get_static_delegate;
 403
 404
 405      [return: MarshalAs(UnmanagedType.U1)] private delegate bool efl_ui_drag_size_set_delegate(System.IntPtr obj, System.IntPtr pd,   double dw,   double dh);
 406
 407
 408      [return: MarshalAs(UnmanagedType.U1)] public delegate bool efl_ui_drag_size_set_api_delegate(System.IntPtr obj,   double dw,   double dh);
 409      public static Efl.Eo.FunctionWrapper<efl_ui_drag_size_set_api_delegate> efl_ui_drag_size_set_ptr = new Efl.Eo.FunctionWrapper<efl_ui_drag_size_set_api_delegate>(_Module, "efl_ui_drag_size_set");
 410      private static bool drag_size_set(System.IntPtr obj, System.IntPtr pd,  double dw,  double dh)
 411     {
 412         Eina.Log.Debug("function efl_ui_drag_size_set was called");
 413         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
 414         if(wrapper != null) {
 415                                                                         bool _ret_var = default(bool);
 416             try {
 417                 _ret_var = ((IDrag)wrapper).SetDragSize( dw,  dh);
 418             } catch (Exception e) {
 419                 Eina.Log.Warning($"Callback error: {e.ToString()}");
 420                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 421             }
 422                                         return _ret_var;
 423         } else {
 424             return efl_ui_drag_size_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  dw,  dh);
 425         }
 426     }
 427     private static efl_ui_drag_size_set_delegate efl_ui_drag_size_set_static_delegate;
 428
 429
 430      private delegate Efl.Ui.DragDir efl_ui_drag_dir_get_delegate(System.IntPtr obj, System.IntPtr pd);
 431
 432
 433      public delegate Efl.Ui.DragDir efl_ui_drag_dir_get_api_delegate(System.IntPtr obj);
 434      public static Efl.Eo.FunctionWrapper<efl_ui_drag_dir_get_api_delegate> efl_ui_drag_dir_get_ptr = new Efl.Eo.FunctionWrapper<efl_ui_drag_dir_get_api_delegate>(_Module, "efl_ui_drag_dir_get");
 435      private static Efl.Ui.DragDir drag_dir_get(System.IntPtr obj, System.IntPtr pd)
 436     {
 437         Eina.Log.Debug("function efl_ui_drag_dir_get was called");
 438         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
 439         if(wrapper != null) {
 440                         Efl.Ui.DragDir _ret_var = default(Efl.Ui.DragDir);
 441             try {
 442                 _ret_var = ((IDrag)wrapper).GetDragDir();
 443             } catch (Exception e) {
 444                 Eina.Log.Warning($"Callback error: {e.ToString()}");
 445                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 446             }
 447         return _ret_var;
 448         } else {
 449             return efl_ui_drag_dir_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
 450         }
 451     }
 452     private static efl_ui_drag_dir_get_delegate efl_ui_drag_dir_get_static_delegate;
 453
 454
 455      [return: MarshalAs(UnmanagedType.U1)] private delegate bool efl_ui_drag_step_get_delegate(System.IntPtr obj, System.IntPtr pd,   out double dx,   out double dy);
 456
 457
 458      [return: MarshalAs(UnmanagedType.U1)] public delegate bool efl_ui_drag_step_get_api_delegate(System.IntPtr obj,   out double dx,   out double dy);
 459      public static Efl.Eo.FunctionWrapper<efl_ui_drag_step_get_api_delegate> efl_ui_drag_step_get_ptr = new Efl.Eo.FunctionWrapper<efl_ui_drag_step_get_api_delegate>(_Module, "efl_ui_drag_step_get");
 460      private static bool drag_step_get(System.IntPtr obj, System.IntPtr pd,  out double dx,  out double dy)
 461     {
 462         Eina.Log.Debug("function efl_ui_drag_step_get was called");
 463         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
 464         if(wrapper != null) {
 465                                     dx = default(double);        dy = default(double);                            bool _ret_var = default(bool);
 466             try {
 467                 _ret_var = ((IDrag)wrapper).GetDragStep( out dx,  out dy);
 468             } catch (Exception e) {
 469                 Eina.Log.Warning($"Callback error: {e.ToString()}");
 470                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 471             }
 472                                         return _ret_var;
 473         } else {
 474             return efl_ui_drag_step_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  out dx,  out dy);
 475         }
 476     }
 477     private static efl_ui_drag_step_get_delegate efl_ui_drag_step_get_static_delegate;
 478
 479
 480      [return: MarshalAs(UnmanagedType.U1)] private delegate bool efl_ui_drag_step_set_delegate(System.IntPtr obj, System.IntPtr pd,   double dx,   double dy);
 481
 482
 483      [return: MarshalAs(UnmanagedType.U1)] public delegate bool efl_ui_drag_step_set_api_delegate(System.IntPtr obj,   double dx,   double dy);
 484      public static Efl.Eo.FunctionWrapper<efl_ui_drag_step_set_api_delegate> efl_ui_drag_step_set_ptr = new Efl.Eo.FunctionWrapper<efl_ui_drag_step_set_api_delegate>(_Module, "efl_ui_drag_step_set");
 485      private static bool drag_step_set(System.IntPtr obj, System.IntPtr pd,  double dx,  double dy)
 486     {
 487         Eina.Log.Debug("function efl_ui_drag_step_set was called");
 488         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
 489         if(wrapper != null) {
 490                                                                         bool _ret_var = default(bool);
 491             try {
 492                 _ret_var = ((IDrag)wrapper).SetDragStep( dx,  dy);
 493             } catch (Exception e) {
 494                 Eina.Log.Warning($"Callback error: {e.ToString()}");
 495                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 496             }
 497                                         return _ret_var;
 498         } else {
 499             return efl_ui_drag_step_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  dx,  dy);
 500         }
 501     }
 502     private static efl_ui_drag_step_set_delegate efl_ui_drag_step_set_static_delegate;
 503
 504
 505      [return: MarshalAs(UnmanagedType.U1)] private delegate bool efl_ui_drag_page_get_delegate(System.IntPtr obj, System.IntPtr pd,   out double dx,   out double dy);
 506
 507
 508      [return: MarshalAs(UnmanagedType.U1)] public delegate bool efl_ui_drag_page_get_api_delegate(System.IntPtr obj,   out double dx,   out double dy);
 509      public static Efl.Eo.FunctionWrapper<efl_ui_drag_page_get_api_delegate> efl_ui_drag_page_get_ptr = new Efl.Eo.FunctionWrapper<efl_ui_drag_page_get_api_delegate>(_Module, "efl_ui_drag_page_get");
 510      private static bool drag_page_get(System.IntPtr obj, System.IntPtr pd,  out double dx,  out double dy)
 511     {
 512         Eina.Log.Debug("function efl_ui_drag_page_get was called");
 513         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
 514         if(wrapper != null) {
 515                                     dx = default(double);        dy = default(double);                            bool _ret_var = default(bool);
 516             try {
 517                 _ret_var = ((IDrag)wrapper).GetDragPage( out dx,  out dy);
 518             } catch (Exception e) {
 519                 Eina.Log.Warning($"Callback error: {e.ToString()}");
 520                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 521             }
 522                                         return _ret_var;
 523         } else {
 524             return efl_ui_drag_page_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  out dx,  out dy);
 525         }
 526     }
 527     private static efl_ui_drag_page_get_delegate efl_ui_drag_page_get_static_delegate;
 528
 529
 530      [return: MarshalAs(UnmanagedType.U1)] private delegate bool efl_ui_drag_page_set_delegate(System.IntPtr obj, System.IntPtr pd,   double dx,   double dy);
 531
 532
 533      [return: MarshalAs(UnmanagedType.U1)] public delegate bool efl_ui_drag_page_set_api_delegate(System.IntPtr obj,   double dx,   double dy);
 534      public static Efl.Eo.FunctionWrapper<efl_ui_drag_page_set_api_delegate> efl_ui_drag_page_set_ptr = new Efl.Eo.FunctionWrapper<efl_ui_drag_page_set_api_delegate>(_Module, "efl_ui_drag_page_set");
 535      private static bool drag_page_set(System.IntPtr obj, System.IntPtr pd,  double dx,  double dy)
 536     {
 537         Eina.Log.Debug("function efl_ui_drag_page_set was called");
 538         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
 539         if(wrapper != null) {
 540                                                                         bool _ret_var = default(bool);
 541             try {
 542                 _ret_var = ((IDrag)wrapper).SetDragPage( dx,  dy);
 543             } catch (Exception e) {
 544                 Eina.Log.Warning($"Callback error: {e.ToString()}");
 545                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 546             }
 547                                         return _ret_var;
 548         } else {
 549             return efl_ui_drag_page_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  dx,  dy);
 550         }
 551     }
 552     private static efl_ui_drag_page_set_delegate efl_ui_drag_page_set_static_delegate;
 553
 554
 555      [return: MarshalAs(UnmanagedType.U1)] private delegate bool efl_ui_drag_step_move_delegate(System.IntPtr obj, System.IntPtr pd,   double dx,   double dy);
 556
 557
 558      [return: MarshalAs(UnmanagedType.U1)] public delegate bool efl_ui_drag_step_move_api_delegate(System.IntPtr obj,   double dx,   double dy);
 559      public static Efl.Eo.FunctionWrapper<efl_ui_drag_step_move_api_delegate> efl_ui_drag_step_move_ptr = new Efl.Eo.FunctionWrapper<efl_ui_drag_step_move_api_delegate>(_Module, "efl_ui_drag_step_move");
 560      private static bool drag_step_move(System.IntPtr obj, System.IntPtr pd,  double dx,  double dy)
 561     {
 562         Eina.Log.Debug("function efl_ui_drag_step_move was called");
 563         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
 564         if(wrapper != null) {
 565                                                                         bool _ret_var = default(bool);
 566             try {
 567                 _ret_var = ((IDrag)wrapper).MoveDragStep( dx,  dy);
 568             } catch (Exception e) {
 569                 Eina.Log.Warning($"Callback error: {e.ToString()}");
 570                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 571             }
 572                                         return _ret_var;
 573         } else {
 574             return efl_ui_drag_step_move_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  dx,  dy);
 575         }
 576     }
 577     private static efl_ui_drag_step_move_delegate efl_ui_drag_step_move_static_delegate;
 578
 579
 580      [return: MarshalAs(UnmanagedType.U1)] private delegate bool efl_ui_drag_page_move_delegate(System.IntPtr obj, System.IntPtr pd,   double dx,   double dy);
 581
 582
 583      [return: MarshalAs(UnmanagedType.U1)] public delegate bool efl_ui_drag_page_move_api_delegate(System.IntPtr obj,   double dx,   double dy);
 584      public static Efl.Eo.FunctionWrapper<efl_ui_drag_page_move_api_delegate> efl_ui_drag_page_move_ptr = new Efl.Eo.FunctionWrapper<efl_ui_drag_page_move_api_delegate>(_Module, "efl_ui_drag_page_move");
 585      private static bool drag_page_move(System.IntPtr obj, System.IntPtr pd,  double dx,  double dy)
 586     {
 587         Eina.Log.Debug("function efl_ui_drag_page_move was called");
 588         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
 589         if(wrapper != null) {
 590                                                                         bool _ret_var = default(bool);
 591             try {
 592                 _ret_var = ((IDrag)wrapper).MoveDragPage( dx,  dy);
 593             } catch (Exception e) {
 594                 Eina.Log.Warning($"Callback error: {e.ToString()}");
 595                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 596             }
 597                                         return _ret_var;
 598         } else {
 599             return efl_ui_drag_page_move_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  dx,  dy);
 600         }
 601     }
 602     private static efl_ui_drag_page_move_delegate efl_ui_drag_page_move_static_delegate;
 603 }
 604 } }