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.Threading;
   7 using System.ComponentModel;
   8 namespace Efl {
   9
  10 namespace Ui {
  11
  12 /// <summary>Common interface for draggable objects and parts.</summary>
  13 [Efl.Ui.IDragConcrete.NativeMethods]
  14 public interface IDrag :
  15     Efl.Eo.IWrapper, IDisposable
  16 {
  17     /// <summary>Gets the draggable object location.</summary>
  18 /// <param name="dx">The x relative position, from 0 to 1.</param>
  19 /// <param name="dy">The y relative position, from 0 to 1.</param>
  20 /// <returns><c>true</c> on success, <c>false</c> otherwise</returns>
  21 bool GetDragValue(out double dx, out double dy);
  22     /// <summary>Sets the draggable object location.
  23 /// This places the draggable object at the given location.</summary>
  24 /// <param name="dx">The x relative position, from 0 to 1.</param>
  25 /// <param name="dy">The y relative position, from 0 to 1.</param>
  26 /// <returns><c>true</c> on success, <c>false</c> otherwise</returns>
  27 bool SetDragValue(double dx, double dy);
  28     /// <summary>Gets the size of the dradgable object.</summary>
  29 /// <param name="dw">The drag relative width, from 0 to 1.</param>
  30 /// <param name="dh">The drag relative height, from 0 to 1.</param>
  31 /// <returns><c>true</c> on success, <c>false</c> otherwise</returns>
  32 bool GetDragSize(out double dw, out double dh);
  33     /// <summary>Sets the size of the draggable object.</summary>
  34 /// <param name="dw">The drag relative width, from 0 to 1.</param>
  35 /// <param name="dh">The drag relative height, from 0 to 1.</param>
  36 /// <returns><c>true</c> on success, <c>false</c> otherwise</returns>
  37 bool SetDragSize(double dw, double dh);
  38     /// <summary>Gets the draggable direction.</summary>
  39 /// <returns>The direction(s) premitted for drag.</returns>
  40 Efl.Ui.DragDir GetDragDir();
  41     /// <summary>Gets the x and y step increments for the draggable object.</summary>
  42 /// <param name="dx">The x step relative amount, from 0 to 1.</param>
  43 /// <param name="dy">The y step relative amount, from 0 to 1.</param>
  44 /// <returns><c>true</c> on success, <c>false</c> otherwise</returns>
  45 bool GetDragStep(out double dx, out double dy);
  46     /// <summary>Sets the x,y step increments for a draggable object.</summary>
  47 /// <param name="dx">The x step relative amount, from 0 to 1.</param>
  48 /// <param name="dy">The y step relative amount, from 0 to 1.</param>
  49 /// <returns><c>true</c> on success, <c>false</c> otherwise</returns>
  50 bool SetDragStep(double dx, double dy);
  51     /// <summary>Gets the x,y page step increments for the draggable object.</summary>
  52 /// <param name="dx">The x page step increment</param>
  53 /// <param name="dy">The y page step increment</param>
  54 /// <returns><c>true</c> on success, <c>false</c> otherwise</returns>
  55 bool GetDragPage(out double dx, out double dy);
  56     /// <summary>Sets the x,y page step increment values.</summary>
  57 /// <param name="dx">The x page step increment</param>
  58 /// <param name="dy">The y page step increment</param>
  59 /// <returns><c>true</c> on success, <c>false</c> otherwise</returns>
  60 bool SetDragPage(double dx, double dy);
  61     /// <summary>Moves the draggable by <c>dx</c>,<c>dy</c> steps.
  62 /// 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"/>.
  63 ///
  64 /// <c>dx</c> and <c>dy</c> can be positive or negative numbers, integer values are recommended.</summary>
  65 /// <param name="dx">The number of steps horizontally.</param>
  66 /// <param name="dy">The number of steps vertically.</param>
  67 /// <returns><c>true</c> on success, <c>false</c> otherwise</returns>
  68 bool MoveDragStep(double dx, double dy);
  69     /// <summary>Moves the draggable by <c>dx</c>,<c>dy</c> pages.
  70 /// This moves the draggable by <c>dx</c>,<c>dy</c> pages. The increment is defined by <see cref="Efl.Ui.IDrag.GetDragPage"/>.
  71 ///
  72 /// <c>dx</c> and <c>dy</c> can be positive or negative numbers, integer values are recommended.
  73 ///
  74 /// Warning: Paging is bugged!</summary>
  75 /// <param name="dx">The number of pages horizontally.</param>
  76 /// <param name="dy">The number of pages vertically.</param>
  77 /// <returns><c>true</c> on success, <c>false</c> otherwise</returns>
  78 bool MoveDragPage(double dx, double dy);
  79                                                 /// <summary>Determines the draggable directions (read-only).
  80 /// 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>
  81 /// <value>The direction(s) premitted for drag.</value>
  82     Efl.Ui.DragDir DragDir {
  83         get ;
  84     }
  85 }
  86 /// <summary>Common interface for draggable objects and parts.</summary>
  87 sealed public class IDragConcrete :
  88
  89 IDrag
  90
  91 {
  92     ///<summary>Pointer to the native class description.</summary>
  93     public System.IntPtr NativeClass
  94     {
  95         get
  96         {
  97             if (((object)this).GetType() == typeof(IDragConcrete))
  98             {
  99                 return GetEflClassStatic();
 100             }
 101             else
 102             {
 103                 return Efl.Eo.ClassRegister.klassFromType[((object)this).GetType()];
 104             }
 105         }
 106     }
 107
 108     private  System.IntPtr handle;
 109     ///<summary>Pointer to the native instance.</summary>
 110     public System.IntPtr NativeHandle
 111     {
 112         get { return handle; }
 113     }
 114
 115     [System.Runtime.InteropServices.DllImport(efl.Libs.Efl)] internal static extern System.IntPtr
 116         efl_ui_drag_interface_get();
 117     /// <summary>Initializes a new instance of the <see cref="IDrag"/> class.
 118     /// Internal usage: This is used when interacting with C code and should not be used directly.</summary>
 119     private IDragConcrete(System.IntPtr raw)
 120     {
 121         handle = raw;
 122     }
 123     ///<summary>Destructor.</summary>
 124     ~IDragConcrete()
 125     {
 126         Dispose(false);
 127     }
 128
 129     ///<summary>Releases the underlying native instance.</summary>
 130     private void Dispose(bool disposing)
 131     {
 132         if (handle != System.IntPtr.Zero)
 133         {
 134             IntPtr h = handle;
 135             handle = IntPtr.Zero;
 136
 137             IntPtr gcHandlePtr = IntPtr.Zero;
 138             if (disposing)
 139             {
 140                 Efl.Eo.Globals.efl_mono_native_dispose(h, gcHandlePtr);
 141             }
 142             else
 143             {
 144                 Monitor.Enter(Efl.All.InitLock);
 145                 if (Efl.All.MainLoopInitialized)
 146                 {
 147                     Efl.Eo.Globals.efl_mono_thread_safe_native_dispose(h, gcHandlePtr);
 148                 }
 149
 150                 Monitor.Exit(Efl.All.InitLock);
 151             }
 152         }
 153
 154     }
 155
 156     ///<summary>Releases the underlying native instance.</summary>
 157     public void Dispose()
 158     {
 159         Dispose(true);
 160         GC.SuppressFinalize(this);
 161     }
 162
 163     /// <summary>Verifies if the given object is equal to this one.</summary>
 164     /// <param name="instance">The object to compare to.</param>
 165     /// <returns>True if both objects point to the same native object.</returns>
 166     public override bool Equals(object instance)
 167     {
 168         var other = instance as Efl.Object;
 169         if (other == null)
 170         {
 171             return false;
 172         }
 173         return this.NativeHandle == other.NativeHandle;
 174     }
 175
 176     /// <summary>Gets the hash code for this object based on the native pointer it points to.</summary>
 177     /// <returns>The value of the pointer, to be used as the hash code of this object.</returns>
 178     public override int GetHashCode()
 179     {
 180         return this.NativeHandle.ToInt32();
 181     }
 182
 183     /// <summary>Turns the native pointer into a string representation.</summary>
 184     /// <returns>A string with the type and the native pointer for this object.</returns>
 185     public override String ToString()
 186     {
 187         return $"{this.GetType().Name}@[{this.NativeHandle.ToInt32():x}]";
 188     }
 189
 190     /// <summary>Gets the draggable object location.</summary>
 191     /// <param name="dx">The x relative position, from 0 to 1.</param>
 192     /// <param name="dy">The y relative position, from 0 to 1.</param>
 193     /// <returns><c>true</c> on success, <c>false</c> otherwise</returns>
 194     public bool GetDragValue(out double dx, out double dy) {
 195                                                          var _ret_var = Efl.Ui.IDragConcrete.NativeMethods.efl_ui_drag_value_get_ptr.Value.Delegate(this.NativeHandle,out dx, out dy);
 196         Eina.Error.RaiseIfUnhandledException();
 197                                         return _ret_var;
 198  }
 199     /// <summary>Sets the draggable object location.
 200     /// This places the draggable object at the given location.</summary>
 201     /// <param name="dx">The x relative position, from 0 to 1.</param>
 202     /// <param name="dy">The y relative position, from 0 to 1.</param>
 203     /// <returns><c>true</c> on success, <c>false</c> otherwise</returns>
 204     public bool SetDragValue(double dx, double dy) {
 205                                                          var _ret_var = Efl.Ui.IDragConcrete.NativeMethods.efl_ui_drag_value_set_ptr.Value.Delegate(this.NativeHandle,dx, dy);
 206         Eina.Error.RaiseIfUnhandledException();
 207                                         return _ret_var;
 208  }
 209     /// <summary>Gets the size of the dradgable object.</summary>
 210     /// <param name="dw">The drag relative width, from 0 to 1.</param>
 211     /// <param name="dh">The drag relative height, from 0 to 1.</param>
 212     /// <returns><c>true</c> on success, <c>false</c> otherwise</returns>
 213     public bool GetDragSize(out double dw, out double dh) {
 214                                                          var _ret_var = Efl.Ui.IDragConcrete.NativeMethods.efl_ui_drag_size_get_ptr.Value.Delegate(this.NativeHandle,out dw, out dh);
 215         Eina.Error.RaiseIfUnhandledException();
 216                                         return _ret_var;
 217  }
 218     /// <summary>Sets the size of the draggable object.</summary>
 219     /// <param name="dw">The drag relative width, from 0 to 1.</param>
 220     /// <param name="dh">The drag relative height, from 0 to 1.</param>
 221     /// <returns><c>true</c> on success, <c>false</c> otherwise</returns>
 222     public bool SetDragSize(double dw, double dh) {
 223                                                          var _ret_var = Efl.Ui.IDragConcrete.NativeMethods.efl_ui_drag_size_set_ptr.Value.Delegate(this.NativeHandle,dw, dh);
 224         Eina.Error.RaiseIfUnhandledException();
 225                                         return _ret_var;
 226  }
 227     /// <summary>Gets the draggable direction.</summary>
 228     /// <returns>The direction(s) premitted for drag.</returns>
 229     public Efl.Ui.DragDir GetDragDir() {
 230          var _ret_var = Efl.Ui.IDragConcrete.NativeMethods.efl_ui_drag_dir_get_ptr.Value.Delegate(this.NativeHandle);
 231         Eina.Error.RaiseIfUnhandledException();
 232         return _ret_var;
 233  }
 234     /// <summary>Gets the x and y step increments for the draggable object.</summary>
 235     /// <param name="dx">The x step relative amount, from 0 to 1.</param>
 236     /// <param name="dy">The y step relative amount, from 0 to 1.</param>
 237     /// <returns><c>true</c> on success, <c>false</c> otherwise</returns>
 238     public bool GetDragStep(out double dx, out double dy) {
 239                                                          var _ret_var = Efl.Ui.IDragConcrete.NativeMethods.efl_ui_drag_step_get_ptr.Value.Delegate(this.NativeHandle,out dx, out dy);
 240         Eina.Error.RaiseIfUnhandledException();
 241                                         return _ret_var;
 242  }
 243     /// <summary>Sets the x,y step increments for a draggable object.</summary>
 244     /// <param name="dx">The x step relative amount, from 0 to 1.</param>
 245     /// <param name="dy">The y step relative amount, from 0 to 1.</param>
 246     /// <returns><c>true</c> on success, <c>false</c> otherwise</returns>
 247     public bool SetDragStep(double dx, double dy) {
 248                                                          var _ret_var = Efl.Ui.IDragConcrete.NativeMethods.efl_ui_drag_step_set_ptr.Value.Delegate(this.NativeHandle,dx, dy);
 249         Eina.Error.RaiseIfUnhandledException();
 250                                         return _ret_var;
 251  }
 252     /// <summary>Gets the x,y page step increments for the draggable object.</summary>
 253     /// <param name="dx">The x page step increment</param>
 254     /// <param name="dy">The y page step increment</param>
 255     /// <returns><c>true</c> on success, <c>false</c> otherwise</returns>
 256     public bool GetDragPage(out double dx, out double dy) {
 257                                                          var _ret_var = Efl.Ui.IDragConcrete.NativeMethods.efl_ui_drag_page_get_ptr.Value.Delegate(this.NativeHandle,out dx, out dy);
 258         Eina.Error.RaiseIfUnhandledException();
 259                                         return _ret_var;
 260  }
 261     /// <summary>Sets the x,y page step increment values.</summary>
 262     /// <param name="dx">The x page step increment</param>
 263     /// <param name="dy">The y page step increment</param>
 264     /// <returns><c>true</c> on success, <c>false</c> otherwise</returns>
 265     public bool SetDragPage(double dx, double dy) {
 266                                                          var _ret_var = Efl.Ui.IDragConcrete.NativeMethods.efl_ui_drag_page_set_ptr.Value.Delegate(this.NativeHandle,dx, dy);
 267         Eina.Error.RaiseIfUnhandledException();
 268                                         return _ret_var;
 269  }
 270     /// <summary>Moves the draggable by <c>dx</c>,<c>dy</c> steps.
 271     /// 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"/>.
 272     ///
 273     /// <c>dx</c> and <c>dy</c> can be positive or negative numbers, integer values are recommended.</summary>
 274     /// <param name="dx">The number of steps horizontally.</param>
 275     /// <param name="dy">The number of steps vertically.</param>
 276     /// <returns><c>true</c> on success, <c>false</c> otherwise</returns>
 277     public bool MoveDragStep(double dx, double dy) {
 278                                                          var _ret_var = Efl.Ui.IDragConcrete.NativeMethods.efl_ui_drag_step_move_ptr.Value.Delegate(this.NativeHandle,dx, dy);
 279         Eina.Error.RaiseIfUnhandledException();
 280                                         return _ret_var;
 281  }
 282     /// <summary>Moves the draggable by <c>dx</c>,<c>dy</c> pages.
 283     /// This moves the draggable by <c>dx</c>,<c>dy</c> pages. The increment is defined by <see cref="Efl.Ui.IDrag.GetDragPage"/>.
 284     ///
 285     /// <c>dx</c> and <c>dy</c> can be positive or negative numbers, integer values are recommended.
 286     ///
 287     /// Warning: Paging is bugged!</summary>
 288     /// <param name="dx">The number of pages horizontally.</param>
 289     /// <param name="dy">The number of pages vertically.</param>
 290     /// <returns><c>true</c> on success, <c>false</c> otherwise</returns>
 291     public bool MoveDragPage(double dx, double dy) {
 292                                                          var _ret_var = Efl.Ui.IDragConcrete.NativeMethods.efl_ui_drag_page_move_ptr.Value.Delegate(this.NativeHandle,dx, dy);
 293         Eina.Error.RaiseIfUnhandledException();
 294                                         return _ret_var;
 295  }
 296     /// <summary>Determines the draggable directions (read-only).
 297 /// 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>
 298 /// <value>The direction(s) premitted for drag.</value>
 299     public Efl.Ui.DragDir DragDir {
 300         get { return GetDragDir(); }
 301     }
 302     private static IntPtr GetEflClassStatic()
 303     {
 304         return Efl.Ui.IDragConcrete.efl_ui_drag_interface_get();
 305     }
 306     /// <summary>Wrapper for native methods and virtual method delegates.
 307     /// For internal use by generated code only.</summary>
 308     public class NativeMethods  : Efl.Eo.NativeClass
 309     {
 310         private static Efl.Eo.NativeModule Module = new Efl.Eo.NativeModule(    efl.Libs.Efl);
 311         /// <summary>Gets the list of Eo operations to override.</summary>
 312         /// <returns>The list of Eo operations to be overload.</returns>
 313         public override System.Collections.Generic.List<Efl_Op_Description> GetEoOps(System.Type type)
 314         {
 315             var descs = new System.Collections.Generic.List<Efl_Op_Description>();
 316             var methods = Efl.Eo.Globals.GetUserMethods(type);
 317
 318             if (efl_ui_drag_value_get_static_delegate == null)
 319             {
 320                 efl_ui_drag_value_get_static_delegate = new efl_ui_drag_value_get_delegate(drag_value_get);
 321             }
 322
 323             if (methods.FirstOrDefault(m => m.Name == "GetDragValue") != null)
 324             {
 325                 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) });
 326             }
 327
 328             if (efl_ui_drag_value_set_static_delegate == null)
 329             {
 330                 efl_ui_drag_value_set_static_delegate = new efl_ui_drag_value_set_delegate(drag_value_set);
 331             }
 332
 333             if (methods.FirstOrDefault(m => m.Name == "SetDragValue") != null)
 334             {
 335                 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) });
 336             }
 337
 338             if (efl_ui_drag_size_get_static_delegate == null)
 339             {
 340                 efl_ui_drag_size_get_static_delegate = new efl_ui_drag_size_get_delegate(drag_size_get);
 341             }
 342
 343             if (methods.FirstOrDefault(m => m.Name == "GetDragSize") != null)
 344             {
 345                 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) });
 346             }
 347
 348             if (efl_ui_drag_size_set_static_delegate == null)
 349             {
 350                 efl_ui_drag_size_set_static_delegate = new efl_ui_drag_size_set_delegate(drag_size_set);
 351             }
 352
 353             if (methods.FirstOrDefault(m => m.Name == "SetDragSize") != null)
 354             {
 355                 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) });
 356             }
 357
 358             if (efl_ui_drag_dir_get_static_delegate == null)
 359             {
 360                 efl_ui_drag_dir_get_static_delegate = new efl_ui_drag_dir_get_delegate(drag_dir_get);
 361             }
 362
 363             if (methods.FirstOrDefault(m => m.Name == "GetDragDir") != null)
 364             {
 365                 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) });
 366             }
 367
 368             if (efl_ui_drag_step_get_static_delegate == null)
 369             {
 370                 efl_ui_drag_step_get_static_delegate = new efl_ui_drag_step_get_delegate(drag_step_get);
 371             }
 372
 373             if (methods.FirstOrDefault(m => m.Name == "GetDragStep") != null)
 374             {
 375                 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) });
 376             }
 377
 378             if (efl_ui_drag_step_set_static_delegate == null)
 379             {
 380                 efl_ui_drag_step_set_static_delegate = new efl_ui_drag_step_set_delegate(drag_step_set);
 381             }
 382
 383             if (methods.FirstOrDefault(m => m.Name == "SetDragStep") != null)
 384             {
 385                 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) });
 386             }
 387
 388             if (efl_ui_drag_page_get_static_delegate == null)
 389             {
 390                 efl_ui_drag_page_get_static_delegate = new efl_ui_drag_page_get_delegate(drag_page_get);
 391             }
 392
 393             if (methods.FirstOrDefault(m => m.Name == "GetDragPage") != null)
 394             {
 395                 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) });
 396             }
 397
 398             if (efl_ui_drag_page_set_static_delegate == null)
 399             {
 400                 efl_ui_drag_page_set_static_delegate = new efl_ui_drag_page_set_delegate(drag_page_set);
 401             }
 402
 403             if (methods.FirstOrDefault(m => m.Name == "SetDragPage") != null)
 404             {
 405                 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) });
 406             }
 407
 408             if (efl_ui_drag_step_move_static_delegate == null)
 409             {
 410                 efl_ui_drag_step_move_static_delegate = new efl_ui_drag_step_move_delegate(drag_step_move);
 411             }
 412
 413             if (methods.FirstOrDefault(m => m.Name == "MoveDragStep") != null)
 414             {
 415                 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) });
 416             }
 417
 418             if (efl_ui_drag_page_move_static_delegate == null)
 419             {
 420                 efl_ui_drag_page_move_static_delegate = new efl_ui_drag_page_move_delegate(drag_page_move);
 421             }
 422
 423             if (methods.FirstOrDefault(m => m.Name == "MoveDragPage") != null)
 424             {
 425                 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) });
 426             }
 427
 428             return descs;
 429         }
 430         /// <summary>Returns the Eo class for the native methods of this class.</summary>
 431         /// <returns>The native class pointer.</returns>
 432         public override IntPtr GetEflClass()
 433         {
 434             return Efl.Ui.IDragConcrete.efl_ui_drag_interface_get();
 435         }
 436
 437         #pragma warning disable CA1707, SA1300, SA1600
 438
 439         [return: MarshalAs(UnmanagedType.U1)]
 440         private delegate bool efl_ui_drag_value_get_delegate(System.IntPtr obj, System.IntPtr pd,  out double dx,  out double dy);
 441
 442         [return: MarshalAs(UnmanagedType.U1)]
 443         public delegate bool efl_ui_drag_value_get_api_delegate(System.IntPtr obj,  out double dx,  out double dy);
 444
 445         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");
 446
 447         private static bool drag_value_get(System.IntPtr obj, System.IntPtr pd, out double dx, out double dy)
 448         {
 449             Eina.Log.Debug("function efl_ui_drag_value_get was called");
 450             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
 451             if (wrapper != null)
 452             {
 453                         dx = default(double);        dy = default(double);                            bool _ret_var = default(bool);
 454                 try
 455                 {
 456                     _ret_var = ((IDrag)wrapper).GetDragValue(out dx, out dy);
 457                 }
 458                 catch (Exception e)
 459                 {
 460                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 461                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 462                 }
 463
 464                                         return _ret_var;
 465
 466             }
 467             else
 468             {
 469                 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);
 470             }
 471         }
 472
 473         private static efl_ui_drag_value_get_delegate efl_ui_drag_value_get_static_delegate;
 474
 475         [return: MarshalAs(UnmanagedType.U1)]
 476         private delegate bool efl_ui_drag_value_set_delegate(System.IntPtr obj, System.IntPtr pd,  double dx,  double dy);
 477
 478         [return: MarshalAs(UnmanagedType.U1)]
 479         public delegate bool efl_ui_drag_value_set_api_delegate(System.IntPtr obj,  double dx,  double dy);
 480
 481         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");
 482
 483         private static bool drag_value_set(System.IntPtr obj, System.IntPtr pd, double dx, double dy)
 484         {
 485             Eina.Log.Debug("function efl_ui_drag_value_set was called");
 486             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
 487             if (wrapper != null)
 488             {
 489                                                             bool _ret_var = default(bool);
 490                 try
 491                 {
 492                     _ret_var = ((IDrag)wrapper).SetDragValue(dx, dy);
 493                 }
 494                 catch (Exception e)
 495                 {
 496                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 497                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 498                 }
 499
 500                                         return _ret_var;
 501
 502             }
 503             else
 504             {
 505                 return efl_ui_drag_value_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), dx, dy);
 506             }
 507         }
 508
 509         private static efl_ui_drag_value_set_delegate efl_ui_drag_value_set_static_delegate;
 510
 511         [return: MarshalAs(UnmanagedType.U1)]
 512         private delegate bool efl_ui_drag_size_get_delegate(System.IntPtr obj, System.IntPtr pd,  out double dw,  out double dh);
 513
 514         [return: MarshalAs(UnmanagedType.U1)]
 515         public delegate bool efl_ui_drag_size_get_api_delegate(System.IntPtr obj,  out double dw,  out double dh);
 516
 517         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");
 518
 519         private static bool drag_size_get(System.IntPtr obj, System.IntPtr pd, out double dw, out double dh)
 520         {
 521             Eina.Log.Debug("function efl_ui_drag_size_get was called");
 522             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
 523             if (wrapper != null)
 524             {
 525                         dw = default(double);        dh = default(double);                            bool _ret_var = default(bool);
 526                 try
 527                 {
 528                     _ret_var = ((IDrag)wrapper).GetDragSize(out dw, out dh);
 529                 }
 530                 catch (Exception e)
 531                 {
 532                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 533                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 534                 }
 535
 536                                         return _ret_var;
 537
 538             }
 539             else
 540             {
 541                 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);
 542             }
 543         }
 544
 545         private static efl_ui_drag_size_get_delegate efl_ui_drag_size_get_static_delegate;
 546
 547         [return: MarshalAs(UnmanagedType.U1)]
 548         private delegate bool efl_ui_drag_size_set_delegate(System.IntPtr obj, System.IntPtr pd,  double dw,  double dh);
 549
 550         [return: MarshalAs(UnmanagedType.U1)]
 551         public delegate bool efl_ui_drag_size_set_api_delegate(System.IntPtr obj,  double dw,  double dh);
 552
 553         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");
 554
 555         private static bool drag_size_set(System.IntPtr obj, System.IntPtr pd, double dw, double dh)
 556         {
 557             Eina.Log.Debug("function efl_ui_drag_size_set was called");
 558             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
 559             if (wrapper != null)
 560             {
 561                                                             bool _ret_var = default(bool);
 562                 try
 563                 {
 564                     _ret_var = ((IDrag)wrapper).SetDragSize(dw, dh);
 565                 }
 566                 catch (Exception e)
 567                 {
 568                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 569                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 570                 }
 571
 572                                         return _ret_var;
 573
 574             }
 575             else
 576             {
 577                 return efl_ui_drag_size_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), dw, dh);
 578             }
 579         }
 580
 581         private static efl_ui_drag_size_set_delegate efl_ui_drag_size_set_static_delegate;
 582
 583
 584         private delegate Efl.Ui.DragDir efl_ui_drag_dir_get_delegate(System.IntPtr obj, System.IntPtr pd);
 585
 586
 587         public delegate Efl.Ui.DragDir efl_ui_drag_dir_get_api_delegate(System.IntPtr obj);
 588
 589         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");
 590
 591         private static Efl.Ui.DragDir drag_dir_get(System.IntPtr obj, System.IntPtr pd)
 592         {
 593             Eina.Log.Debug("function efl_ui_drag_dir_get was called");
 594             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
 595             if (wrapper != null)
 596             {
 597             Efl.Ui.DragDir _ret_var = default(Efl.Ui.DragDir);
 598                 try
 599                 {
 600                     _ret_var = ((IDrag)wrapper).GetDragDir();
 601                 }
 602                 catch (Exception e)
 603                 {
 604                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 605                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 606                 }
 607
 608         return _ret_var;
 609
 610             }
 611             else
 612             {
 613                 return efl_ui_drag_dir_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
 614             }
 615         }
 616
 617         private static efl_ui_drag_dir_get_delegate efl_ui_drag_dir_get_static_delegate;
 618
 619         [return: MarshalAs(UnmanagedType.U1)]
 620         private delegate bool efl_ui_drag_step_get_delegate(System.IntPtr obj, System.IntPtr pd,  out double dx,  out double dy);
 621
 622         [return: MarshalAs(UnmanagedType.U1)]
 623         public delegate bool efl_ui_drag_step_get_api_delegate(System.IntPtr obj,  out double dx,  out double dy);
 624
 625         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");
 626
 627         private static bool drag_step_get(System.IntPtr obj, System.IntPtr pd, out double dx, out double dy)
 628         {
 629             Eina.Log.Debug("function efl_ui_drag_step_get was called");
 630             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
 631             if (wrapper != null)
 632             {
 633                         dx = default(double);        dy = default(double);                            bool _ret_var = default(bool);
 634                 try
 635                 {
 636                     _ret_var = ((IDrag)wrapper).GetDragStep(out dx, out dy);
 637                 }
 638                 catch (Exception e)
 639                 {
 640                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 641                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 642                 }
 643
 644                                         return _ret_var;
 645
 646             }
 647             else
 648             {
 649                 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);
 650             }
 651         }
 652
 653         private static efl_ui_drag_step_get_delegate efl_ui_drag_step_get_static_delegate;
 654
 655         [return: MarshalAs(UnmanagedType.U1)]
 656         private delegate bool efl_ui_drag_step_set_delegate(System.IntPtr obj, System.IntPtr pd,  double dx,  double dy);
 657
 658         [return: MarshalAs(UnmanagedType.U1)]
 659         public delegate bool efl_ui_drag_step_set_api_delegate(System.IntPtr obj,  double dx,  double dy);
 660
 661         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");
 662
 663         private static bool drag_step_set(System.IntPtr obj, System.IntPtr pd, double dx, double dy)
 664         {
 665             Eina.Log.Debug("function efl_ui_drag_step_set was called");
 666             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
 667             if (wrapper != null)
 668             {
 669                                                             bool _ret_var = default(bool);
 670                 try
 671                 {
 672                     _ret_var = ((IDrag)wrapper).SetDragStep(dx, dy);
 673                 }
 674                 catch (Exception e)
 675                 {
 676                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 677                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 678                 }
 679
 680                                         return _ret_var;
 681
 682             }
 683             else
 684             {
 685                 return efl_ui_drag_step_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), dx, dy);
 686             }
 687         }
 688
 689         private static efl_ui_drag_step_set_delegate efl_ui_drag_step_set_static_delegate;
 690
 691         [return: MarshalAs(UnmanagedType.U1)]
 692         private delegate bool efl_ui_drag_page_get_delegate(System.IntPtr obj, System.IntPtr pd,  out double dx,  out double dy);
 693
 694         [return: MarshalAs(UnmanagedType.U1)]
 695         public delegate bool efl_ui_drag_page_get_api_delegate(System.IntPtr obj,  out double dx,  out double dy);
 696
 697         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");
 698
 699         private static bool drag_page_get(System.IntPtr obj, System.IntPtr pd, out double dx, out double dy)
 700         {
 701             Eina.Log.Debug("function efl_ui_drag_page_get was called");
 702             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
 703             if (wrapper != null)
 704             {
 705                         dx = default(double);        dy = default(double);                            bool _ret_var = default(bool);
 706                 try
 707                 {
 708                     _ret_var = ((IDrag)wrapper).GetDragPage(out dx, out dy);
 709                 }
 710                 catch (Exception e)
 711                 {
 712                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 713                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 714                 }
 715
 716                                         return _ret_var;
 717
 718             }
 719             else
 720             {
 721                 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);
 722             }
 723         }
 724
 725         private static efl_ui_drag_page_get_delegate efl_ui_drag_page_get_static_delegate;
 726
 727         [return: MarshalAs(UnmanagedType.U1)]
 728         private delegate bool efl_ui_drag_page_set_delegate(System.IntPtr obj, System.IntPtr pd,  double dx,  double dy);
 729
 730         [return: MarshalAs(UnmanagedType.U1)]
 731         public delegate bool efl_ui_drag_page_set_api_delegate(System.IntPtr obj,  double dx,  double dy);
 732
 733         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");
 734
 735         private static bool drag_page_set(System.IntPtr obj, System.IntPtr pd, double dx, double dy)
 736         {
 737             Eina.Log.Debug("function efl_ui_drag_page_set was called");
 738             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
 739             if (wrapper != null)
 740             {
 741                                                             bool _ret_var = default(bool);
 742                 try
 743                 {
 744                     _ret_var = ((IDrag)wrapper).SetDragPage(dx, dy);
 745                 }
 746                 catch (Exception e)
 747                 {
 748                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 749                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 750                 }
 751
 752                                         return _ret_var;
 753
 754             }
 755             else
 756             {
 757                 return efl_ui_drag_page_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), dx, dy);
 758             }
 759         }
 760
 761         private static efl_ui_drag_page_set_delegate efl_ui_drag_page_set_static_delegate;
 762
 763         [return: MarshalAs(UnmanagedType.U1)]
 764         private delegate bool efl_ui_drag_step_move_delegate(System.IntPtr obj, System.IntPtr pd,  double dx,  double dy);
 765
 766         [return: MarshalAs(UnmanagedType.U1)]
 767         public delegate bool efl_ui_drag_step_move_api_delegate(System.IntPtr obj,  double dx,  double dy);
 768
 769         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");
 770
 771         private static bool drag_step_move(System.IntPtr obj, System.IntPtr pd, double dx, double dy)
 772         {
 773             Eina.Log.Debug("function efl_ui_drag_step_move was called");
 774             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
 775             if (wrapper != null)
 776             {
 777                                                             bool _ret_var = default(bool);
 778                 try
 779                 {
 780                     _ret_var = ((IDrag)wrapper).MoveDragStep(dx, dy);
 781                 }
 782                 catch (Exception e)
 783                 {
 784                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 785                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 786                 }
 787
 788                                         return _ret_var;
 789
 790             }
 791             else
 792             {
 793                 return efl_ui_drag_step_move_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), dx, dy);
 794             }
 795         }
 796
 797         private static efl_ui_drag_step_move_delegate efl_ui_drag_step_move_static_delegate;
 798
 799         [return: MarshalAs(UnmanagedType.U1)]
 800         private delegate bool efl_ui_drag_page_move_delegate(System.IntPtr obj, System.IntPtr pd,  double dx,  double dy);
 801
 802         [return: MarshalAs(UnmanagedType.U1)]
 803         public delegate bool efl_ui_drag_page_move_api_delegate(System.IntPtr obj,  double dx,  double dy);
 804
 805         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");
 806
 807         private static bool drag_page_move(System.IntPtr obj, System.IntPtr pd, double dx, double dy)
 808         {
 809             Eina.Log.Debug("function efl_ui_drag_page_move was called");
 810             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
 811             if (wrapper != null)
 812             {
 813                                                             bool _ret_var = default(bool);
 814                 try
 815                 {
 816                     _ret_var = ((IDrag)wrapper).MoveDragPage(dx, dy);
 817                 }
 818                 catch (Exception e)
 819                 {
 820                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 821                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 822                 }
 823
 824                                         return _ret_var;
 825
 826             }
 827             else
 828             {
 829                 return efl_ui_drag_page_move_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), dx, dy);
 830             }
 831         }
 832
 833         private static efl_ui_drag_page_move_delegate efl_ui_drag_page_move_static_delegate;
 834
 835         #pragma warning restore CA1707, SA1300, SA1600
 836
 837 }
 838 }
 839 }
 840
 841 }
 842