internals/src/EflSharp/EflSharp/efl/efl_ui_dnd_types.eot.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 Dnd {
  11
  12 /// <param name="win">The window to create the objects relative to</param>
  13 /// <param name="drag_obj">The drag object</param>
  14 /// <param name="off">Offset from the icon position to the cursor</param>
  15 public delegate Efl.Canvas.Object DragIconCreate(Efl.Canvas.Object win, Efl.Canvas.Object drag_obj, out Eina.Position2D off);
  16 [return:MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))]public delegate Efl.Canvas.Object DragIconCreateInternal(IntPtr data, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))] Efl.Canvas.Object win, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))] Efl.Canvas.Object drag_obj,  out Eina.Position2D.NativeStruct off);
  17 internal class DragIconCreateWrapper : IDisposable
  18 {
  19
  20     private DragIconCreateInternal _cb;
  21     private IntPtr _cb_data;
  22     private EinaFreeCb _cb_free_cb;
  23
  24     internal DragIconCreateWrapper (DragIconCreateInternal _cb, IntPtr _cb_data, EinaFreeCb _cb_free_cb)
  25     {
  26         this._cb = _cb;
  27         this._cb_data = _cb_data;
  28         this._cb_free_cb = _cb_free_cb;
  29     }
  30
  31     ~DragIconCreateWrapper()
  32     {
  33         Dispose(false);
  34     }
  35
  36     protected virtual void Dispose(bool disposing)
  37     {
  38         if (this._cb_free_cb != null)
  39         {
  40             if (disposing)
  41             {
  42                 this._cb_free_cb(this._cb_data);
  43             }
  44             else
  45             {
  46                 Efl.Eo.Globals.ThreadSafeFreeCbExec(this._cb_free_cb, this._cb_data);
  47             }
  48             this._cb_free_cb = null;
  49             this._cb_data = IntPtr.Zero;
  50             this._cb = null;
  51         }
  52     }
  53
  54     public void Dispose()
  55     {
  56         Dispose(true);
  57         GC.SuppressFinalize(this);
  58     }
  59
  60     internal Efl.Canvas.Object ManagedCb(Efl.Canvas.Object win,Efl.Canvas.Object drag_obj,out Eina.Position2D off)
  61     {
  62                                                 var _out_off = new Eina.Position2D.NativeStruct();
  63                                 var _ret_var = _cb(_cb_data, win, drag_obj, out _out_off);
  64         Eina.Error.RaiseIfUnhandledException();
  65                         off = _out_off;
  66                                 return _ret_var;
  67     }
  68
  69     [return:MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))]    internal static Efl.Canvas.Object Cb(IntPtr cb_data, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))] Efl.Canvas.Object win, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))] Efl.Canvas.Object drag_obj,  out Eina.Position2D.NativeStruct off)
  70     {
  71         GCHandle handle = GCHandle.FromIntPtr(cb_data);
  72         DragIconCreate cb = (DragIconCreate)handle.Target;
  73                                                 Eina.Position2D _out_off = default(Eina.Position2D);
  74                                     Efl.Canvas.Object _ret_var = default(Efl.Canvas.Object);
  75         try {
  76             _ret_var = cb(win, drag_obj, out _out_off);
  77         } catch (Exception e) {
  78             Eina.Log.Warning($"Callback error: {e.ToString()}");
  79             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
  80         }
  81                         off = _out_off;
  82                                 return _ret_var;
  83     }
  84 }
  85 }
  86
  87 }
  88
  89 namespace Efl {
  90
  91 namespace Dnd {
  92
  93 /// <param name="obj">The container object</param>
  94 /// <param name="format">Data format</param>
  95 /// <param name="drag_data">Data</param>
  96 /// <param name="action">The drag action</param>
  97 public delegate void DragDataGet(Efl.Canvas.Object obj, out Efl.Ui.SelectionFormat format, ref Eina.RwSlice drag_data, out Efl.Ui.SelectionAction action);
  98 public delegate void DragDataGetInternal(IntPtr data, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))] Efl.Canvas.Object obj,  out Efl.Ui.SelectionFormat format,  ref Eina.RwSlice drag_data,  out Efl.Ui.SelectionAction action);
  99 internal class DragDataGetWrapper : IDisposable
 100 {
 101
 102     private DragDataGetInternal _cb;
 103     private IntPtr _cb_data;
 104     private EinaFreeCb _cb_free_cb;
 105
 106     internal DragDataGetWrapper (DragDataGetInternal _cb, IntPtr _cb_data, EinaFreeCb _cb_free_cb)
 107     {
 108         this._cb = _cb;
 109         this._cb_data = _cb_data;
 110         this._cb_free_cb = _cb_free_cb;
 111     }
 112
 113     ~DragDataGetWrapper()
 114     {
 115         Dispose(false);
 116     }
 117
 118     protected virtual void Dispose(bool disposing)
 119     {
 120         if (this._cb_free_cb != null)
 121         {
 122             if (disposing)
 123             {
 124                 this._cb_free_cb(this._cb_data);
 125             }
 126             else
 127             {
 128                 Efl.Eo.Globals.ThreadSafeFreeCbExec(this._cb_free_cb, this._cb_data);
 129             }
 130             this._cb_free_cb = null;
 131             this._cb_data = IntPtr.Zero;
 132             this._cb = null;
 133         }
 134     }
 135
 136     public void Dispose()
 137     {
 138         Dispose(true);
 139         GC.SuppressFinalize(this);
 140     }
 141
 142     internal void ManagedCb(Efl.Canvas.Object obj,out Efl.Ui.SelectionFormat format,ref Eina.RwSlice drag_data,out Efl.Ui.SelectionAction action)
 143     {
 144                                                                                                         _cb(_cb_data, obj, out format, ref drag_data, out action);
 145         Eina.Error.RaiseIfUnhandledException();
 146                                                                             }
 147
 148         internal static void Cb(IntPtr cb_data, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))] Efl.Canvas.Object obj,  out Efl.Ui.SelectionFormat format,  ref Eina.RwSlice drag_data,  out Efl.Ui.SelectionAction action)
 149     {
 150         GCHandle handle = GCHandle.FromIntPtr(cb_data);
 151         DragDataGet cb = (DragDataGet)handle.Target;
 152                                                 format = default(Efl.Ui.SelectionFormat);        drag_data = default(Eina.RwSlice);        action = default(Efl.Ui.SelectionAction);
 153         try {
 154             cb(obj, out format, ref drag_data, out action);
 155         } catch (Exception e) {
 156             Eina.Log.Warning($"Callback error: {e.ToString()}");
 157             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 158         }
 159                                                                             }
 160 }
 161 }
 162
 163 }
 164
 165 namespace Efl {
 166
 167 namespace Dnd {
 168
 169 /// <param name="obj">The container object</param>
 170 /// <param name="pos">The coordinates to get item</param>
 171 /// <param name="posret">position relative to item (left (-1), middle (0), right (1)</param>
 172 public delegate Efl.Object ItemGet(Efl.Canvas.Object obj, Eina.Position2D pos, out Eina.Position2D posret);
 173 [return:MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))]public delegate Efl.Object ItemGetInternal(IntPtr data, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))] Efl.Canvas.Object obj,  Eina.Position2D.NativeStruct pos,  out Eina.Position2D.NativeStruct posret);
 174 internal class ItemGetWrapper : IDisposable
 175 {
 176
 177     private ItemGetInternal _cb;
 178     private IntPtr _cb_data;
 179     private EinaFreeCb _cb_free_cb;
 180
 181     internal ItemGetWrapper (ItemGetInternal _cb, IntPtr _cb_data, EinaFreeCb _cb_free_cb)
 182     {
 183         this._cb = _cb;
 184         this._cb_data = _cb_data;
 185         this._cb_free_cb = _cb_free_cb;
 186     }
 187
 188     ~ItemGetWrapper()
 189     {
 190         Dispose(false);
 191     }
 192
 193     protected virtual void Dispose(bool disposing)
 194     {
 195         if (this._cb_free_cb != null)
 196         {
 197             if (disposing)
 198             {
 199                 this._cb_free_cb(this._cb_data);
 200             }
 201             else
 202             {
 203                 Efl.Eo.Globals.ThreadSafeFreeCbExec(this._cb_free_cb, this._cb_data);
 204             }
 205             this._cb_free_cb = null;
 206             this._cb_data = IntPtr.Zero;
 207             this._cb = null;
 208         }
 209     }
 210
 211     public void Dispose()
 212     {
 213         Dispose(true);
 214         GC.SuppressFinalize(this);
 215     }
 216
 217     internal Efl.Object ManagedCb(Efl.Canvas.Object obj,Eina.Position2D pos,out Eina.Position2D posret)
 218     {
 219                 Eina.Position2D.NativeStruct _in_pos = pos;
 220                                 var _out_posret = new Eina.Position2D.NativeStruct();
 221                                 var _ret_var = _cb(_cb_data, obj, _in_pos, out _out_posret);
 222         Eina.Error.RaiseIfUnhandledException();
 223                         posret = _out_posret;
 224                                 return _ret_var;
 225     }
 226
 227     [return:MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))]    internal static Efl.Object Cb(IntPtr cb_data, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))] Efl.Canvas.Object obj,  Eina.Position2D.NativeStruct pos,  out Eina.Position2D.NativeStruct posret)
 228     {
 229         GCHandle handle = GCHandle.FromIntPtr(cb_data);
 230         ItemGet cb = (ItemGet)handle.Target;
 231                 Eina.Position2D _in_pos = pos;
 232                                 Eina.Position2D _out_posret = default(Eina.Position2D);
 233                                     Efl.Object _ret_var = default(Efl.Object);
 234         try {
 235             _ret_var = cb(obj, _in_pos, out _out_posret);
 236         } catch (Exception e) {
 237             Eina.Log.Warning($"Callback error: {e.ToString()}");
 238             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 239         }
 240                         posret = _out_posret;
 241                                 return _ret_var;
 242     }
 243 }
 244 }
 245
 246 }
 247
 248 namespace Efl {
 249
 250 namespace Dnd {
 251
 252 /// <param name="obj">The container object</param>
 253 public delegate Eina.List<Efl.Canvas.Object> DragIconListCreate(Efl.Canvas.Object obj);
 254 public delegate System.IntPtr DragIconListCreateInternal(IntPtr data, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))] Efl.Canvas.Object obj);
 255 internal class DragIconListCreateWrapper : IDisposable
 256 {
 257
 258     private DragIconListCreateInternal _cb;
 259     private IntPtr _cb_data;
 260     private EinaFreeCb _cb_free_cb;
 261
 262     internal DragIconListCreateWrapper (DragIconListCreateInternal _cb, IntPtr _cb_data, EinaFreeCb _cb_free_cb)
 263     {
 264         this._cb = _cb;
 265         this._cb_data = _cb_data;
 266         this._cb_free_cb = _cb_free_cb;
 267     }
 268
 269     ~DragIconListCreateWrapper()
 270     {
 271         Dispose(false);
 272     }
 273
 274     protected virtual void Dispose(bool disposing)
 275     {
 276         if (this._cb_free_cb != null)
 277         {
 278             if (disposing)
 279             {
 280                 this._cb_free_cb(this._cb_data);
 281             }
 282             else
 283             {
 284                 Efl.Eo.Globals.ThreadSafeFreeCbExec(this._cb_free_cb, this._cb_data);
 285             }
 286             this._cb_free_cb = null;
 287             this._cb_data = IntPtr.Zero;
 288             this._cb = null;
 289         }
 290     }
 291
 292     public void Dispose()
 293     {
 294         Dispose(true);
 295         GC.SuppressFinalize(this);
 296     }
 297
 298     internal Eina.List<Efl.Canvas.Object> ManagedCb(Efl.Canvas.Object obj)
 299     {
 300                                 var _ret_var = _cb(_cb_data, obj);
 301         Eina.Error.RaiseIfUnhandledException();
 302                         return new Eina.List<Efl.Canvas.Object>(_ret_var, false, false);
 303     }
 304
 305         internal static System.IntPtr Cb(IntPtr cb_data, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))] Efl.Canvas.Object obj)
 306     {
 307         GCHandle handle = GCHandle.FromIntPtr(cb_data);
 308         DragIconListCreate cb = (DragIconListCreate)handle.Target;
 309                                     Eina.List<Efl.Canvas.Object> _ret_var = default(Eina.List<Efl.Canvas.Object>);
 310         try {
 311             _ret_var = cb(obj);
 312         } catch (Exception e) {
 313             Eina.Log.Warning($"Callback error: {e.ToString()}");
 314             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 315         }
 316                         return _ret_var.Handle;
 317     }
 318 }
 319 }
 320
 321 }
 322
 323 namespace Efl {
 324
 325 namespace Dnd {
 326
 327 [StructLayout(LayoutKind.Sequential)]
 328 public struct DragAccept
 329 {
 330     public bool Accepted;
 331     ///<summary>Constructor for DragAccept.</summary>
 332     public DragAccept(
 333         bool Accepted = default(bool)    )
 334     {
 335         this.Accepted = Accepted;
 336     }
 337
 338     ///<summary>Implicit conversion to the managed representation from a native pointer.</summary>
 339     ///<param name="ptr">Native pointer to be converted.</param>
 340     public static implicit operator DragAccept(IntPtr ptr)
 341     {
 342         var tmp = (DragAccept.NativeStruct)Marshal.PtrToStructure(ptr, typeof(DragAccept.NativeStruct));
 343         return tmp;
 344     }
 345
 346     #pragma warning disable CS1591
 347
 348     ///<summary>Internal wrapper for struct DragAccept.</summary>
 349     [StructLayout(LayoutKind.Sequential)]
 350     public struct NativeStruct
 351     {
 352         ///<summary>Internal wrapper for field Accepted</summary>
 353         public System.Byte Accepted;
 354         ///<summary>Implicit conversion to the internal/marshalling representation.</summary>
 355         public static implicit operator DragAccept.NativeStruct(DragAccept _external_struct)
 356         {
 357             var _internal_struct = new DragAccept.NativeStruct();
 358             _internal_struct.Accepted = _external_struct.Accepted ? (byte)1 : (byte)0;
 359             return _internal_struct;
 360         }
 361
 362         ///<summary>Implicit conversion to the managed representation.</summary>
 363         public static implicit operator DragAccept(DragAccept.NativeStruct _internal_struct)
 364         {
 365             var _external_struct = new DragAccept();
 366             _external_struct.Accepted = _internal_struct.Accepted != 0;
 367             return _external_struct;
 368         }
 369
 370     }
 371
 372     #pragma warning restore CS1591
 373
 374 }
 375
 376 }
 377
 378 }
 379
 380 namespace Efl {
 381
 382 namespace Dnd {
 383
 384 [StructLayout(LayoutKind.Sequential)]
 385 public struct DragPos
 386 {
 387     /// <summary>Evas Coordinate</summary>
 388     public Eina.Position2D Pos;
 389     /// <summary>The drag action</summary>
 390     public Efl.Ui.SelectionAction Action;
 391     /// <summary>The drag format</summary>
 392     public Efl.Ui.SelectionFormat Format;
 393     /// <summary>The item object. It is only available for container object.</summary>
 394     public Efl.Canvas.Object Item;
 395     ///<summary>Constructor for DragPos.</summary>
 396     public DragPos(
 397         Eina.Position2D Pos = default(Eina.Position2D),
 398         Efl.Ui.SelectionAction Action = default(Efl.Ui.SelectionAction),
 399         Efl.Ui.SelectionFormat Format = default(Efl.Ui.SelectionFormat),
 400         Efl.Canvas.Object Item = default(Efl.Canvas.Object)    )
 401     {
 402         this.Pos = Pos;
 403         this.Action = Action;
 404         this.Format = Format;
 405         this.Item = Item;
 406     }
 407
 408     ///<summary>Implicit conversion to the managed representation from a native pointer.</summary>
 409     ///<param name="ptr">Native pointer to be converted.</param>
 410     public static implicit operator DragPos(IntPtr ptr)
 411     {
 412         var tmp = (DragPos.NativeStruct)Marshal.PtrToStructure(ptr, typeof(DragPos.NativeStruct));
 413         return tmp;
 414     }
 415
 416     #pragma warning disable CS1591
 417
 418     ///<summary>Internal wrapper for struct DragPos.</summary>
 419     [StructLayout(LayoutKind.Sequential)]
 420     public struct NativeStruct
 421     {
 422
 423         public Eina.Position2D.NativeStruct Pos;
 424
 425         public Efl.Ui.SelectionAction Action;
 426
 427         public Efl.Ui.SelectionFormat Format;
 428         ///<summary>Internal wrapper for field Item</summary>
 429         public System.IntPtr Item;
 430         ///<summary>Implicit conversion to the internal/marshalling representation.</summary>
 431         public static implicit operator DragPos.NativeStruct(DragPos _external_struct)
 432         {
 433             var _internal_struct = new DragPos.NativeStruct();
 434             _internal_struct.Pos = _external_struct.Pos;
 435             _internal_struct.Action = _external_struct.Action;
 436             _internal_struct.Format = _external_struct.Format;
 437             _internal_struct.Item = _external_struct.Item?.NativeHandle ?? System.IntPtr.Zero;
 438             return _internal_struct;
 439         }
 440
 441         ///<summary>Implicit conversion to the managed representation.</summary>
 442         public static implicit operator DragPos(DragPos.NativeStruct _internal_struct)
 443         {
 444             var _external_struct = new DragPos();
 445             _external_struct.Pos = _internal_struct.Pos;
 446             _external_struct.Action = _internal_struct.Action;
 447             _external_struct.Format = _internal_struct.Format;
 448
 449             _external_struct.Item = (Efl.Canvas.Object) Efl.Eo.Globals.CreateWrapperFor(_internal_struct.Item);
 450             return _external_struct;
 451         }
 452
 453     }
 454
 455     #pragma warning restore CS1591
 456
 457 }
 458
 459 }
 460
 461 }
 462
 463 namespace Efl {
 464
 465 namespace Dnd {
 466
 467 [StructLayout(LayoutKind.Sequential)]
 468 public struct DragItemContainerDrop
 469 {
 470     /// <summary>The item object</summary>
 471     public Efl.Canvas.Object Item;
 472     /// <summary>The selection data</summary>
 473     public Efl.Ui.SelectionData Data;
 474     /// <summary>Position relative to item (left (-1), middle (0), right (1)</summary>
 475     public Eina.Position2D Pos;
 476     ///<summary>Constructor for DragItemContainerDrop.</summary>
 477     public DragItemContainerDrop(
 478         Efl.Canvas.Object Item = default(Efl.Canvas.Object),
 479         Efl.Ui.SelectionData Data = default(Efl.Ui.SelectionData),
 480         Eina.Position2D Pos = default(Eina.Position2D)    )
 481     {
 482         this.Item = Item;
 483         this.Data = Data;
 484         this.Pos = Pos;
 485     }
 486
 487     ///<summary>Implicit conversion to the managed representation from a native pointer.</summary>
 488     ///<param name="ptr">Native pointer to be converted.</param>
 489     public static implicit operator DragItemContainerDrop(IntPtr ptr)
 490     {
 491         var tmp = (DragItemContainerDrop.NativeStruct)Marshal.PtrToStructure(ptr, typeof(DragItemContainerDrop.NativeStruct));
 492         return tmp;
 493     }
 494
 495     #pragma warning disable CS1591
 496
 497     ///<summary>Internal wrapper for struct DragItemContainerDrop.</summary>
 498     [StructLayout(LayoutKind.Sequential)]
 499     public struct NativeStruct
 500     {
 501         ///<summary>Internal wrapper for field Item</summary>
 502         public System.IntPtr Item;
 503
 504         public Efl.Ui.SelectionData.NativeStruct Data;
 505
 506         public Eina.Position2D.NativeStruct Pos;
 507         ///<summary>Implicit conversion to the internal/marshalling representation.</summary>
 508         public static implicit operator DragItemContainerDrop.NativeStruct(DragItemContainerDrop _external_struct)
 509         {
 510             var _internal_struct = new DragItemContainerDrop.NativeStruct();
 511             _internal_struct.Item = _external_struct.Item?.NativeHandle ?? System.IntPtr.Zero;
 512             _internal_struct.Data = _external_struct.Data;
 513             _internal_struct.Pos = _external_struct.Pos;
 514             return _internal_struct;
 515         }
 516
 517         ///<summary>Implicit conversion to the managed representation.</summary>
 518         public static implicit operator DragItemContainerDrop(DragItemContainerDrop.NativeStruct _internal_struct)
 519         {
 520             var _external_struct = new DragItemContainerDrop();
 521
 522             _external_struct.Item = (Efl.Canvas.Object) Efl.Eo.Globals.CreateWrapperFor(_internal_struct.Item);
 523             _external_struct.Data = _internal_struct.Data;
 524             _external_struct.Pos = _internal_struct.Pos;
 525             return _external_struct;
 526         }
 527
 528     }
 529
 530     #pragma warning restore CS1591
 531
 532 }
 533
 534 }
 535
 536 }
 537