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

   1 #define EFL_BETA
   2 #pragma warning disable CS1591
   3 using System;
   4 using System.Runtime.InteropServices;
   5 using System.Collections.Generic;
   6 using System.Linq;
   7 using System.Threading;
   8 using System.ComponentModel;
   9 namespace Efl {
  10
  11 namespace Ui {
  12
  13 /// <summary>Efl UI draggable interface</summary>
  14 /// <remarks>This is a <b>BETA</b> class. It can be modified or removed in the future. Do not use it for product development.</remarks>
  15 [Efl.Ui.IDraggableConcrete.NativeMethods]
  16 [Efl.Eo.BindingEntity]
  17 public interface IDraggable :
  18     Efl.Eo.IWrapper, IDisposable
  19 {
  20     /// <summary>Control whether the object&apos;s content is changed by drag and drop.
  21 /// If <c>drag_target</c> is true the object can be the target of a dragging object. The content of this object can then be changed into dragging content. For example, if an object deals with image and <c>drag_target</c> is true, the user can drag the new image and drop it into said object. This object&apos;s image can then be changed into a new image.</summary>
  22 /// <returns>Turn on or off drop_target. Default is <c>false</c>.</returns>
  23 bool GetDragTarget();
  24     /// <summary>Control whether the object&apos;s content is changed by drag and drop.
  25 /// If <c>drag_target</c> is true the object can be the target of a dragging object. The content of this object can then be changed into dragging content. For example, if an object deals with image and <c>drag_target</c> is true, the user can drag the new image and drop it into said object. This object&apos;s image can then be changed into a new image.</summary>
  26 /// <param name="set">Turn on or off drop_target. Default is <c>false</c>.</param>
  27 void SetDragTarget(bool set);
  28             /// <summary>Called when drag operation starts</summary>
  29     /// <value><see cref="Efl.Ui.IDraggableDragEvt_Args"/></value>
  30     event EventHandler<Efl.Ui.IDraggableDragEvt_Args> DragEvt;
  31     /// <summary>Called when drag started</summary>
  32     event EventHandler DragStartEvt;
  33     /// <summary>Called when drag stopped</summary>
  34     /// <value><see cref="Efl.Ui.IDraggableDragStopEvt_Args"/></value>
  35     event EventHandler<Efl.Ui.IDraggableDragStopEvt_Args> DragStopEvt;
  36     /// <summary>Called when drag operation ends</summary>
  37     event EventHandler DragEndEvt;
  38     /// <summary>Called when drag starts into up direction</summary>
  39     /// <value><see cref="Efl.Ui.IDraggableDragStartUpEvt_Args"/></value>
  40     event EventHandler<Efl.Ui.IDraggableDragStartUpEvt_Args> DragStartUpEvt;
  41     /// <summary>Called when drag starts into down direction</summary>
  42     /// <value><see cref="Efl.Ui.IDraggableDragStartDownEvt_Args"/></value>
  43     event EventHandler<Efl.Ui.IDraggableDragStartDownEvt_Args> DragStartDownEvt;
  44     /// <summary>Called when drag starts into right direction</summary>
  45     /// <value><see cref="Efl.Ui.IDraggableDragStartRightEvt_Args"/></value>
  46     event EventHandler<Efl.Ui.IDraggableDragStartRightEvt_Args> DragStartRightEvt;
  47     /// <summary>Called when drag starts into left direction</summary>
  48     /// <value><see cref="Efl.Ui.IDraggableDragStartLeftEvt_Args"/></value>
  49     event EventHandler<Efl.Ui.IDraggableDragStartLeftEvt_Args> DragStartLeftEvt;
  50     /// <summary>Control whether the object&apos;s content is changed by drag and drop.
  51     /// If <c>drag_target</c> is true the object can be the target of a dragging object. The content of this object can then be changed into dragging content. For example, if an object deals with image and <c>drag_target</c> is true, the user can drag the new image and drop it into said object. This object&apos;s image can then be changed into a new image.</summary>
  52     /// <value>Turn on or off drop_target. Default is <c>false</c>.</value>
  53     bool DragTarget {
  54         get;
  55         set;
  56     }
  57 }
  58 /// <summary>Event argument wrapper for event <see cref="Efl.Ui.IDraggable.DragEvt"/>.</summary>
  59 [Efl.Eo.BindingEntity]
  60 public class IDraggableDragEvt_Args : EventArgs {
  61     /// <summary>Actual event payload.</summary>
  62     /// <value>Called when drag operation starts</value>
  63     public Efl.Object arg { get; set; }
  64 }
  65 /// <summary>Event argument wrapper for event <see cref="Efl.Ui.IDraggable.DragStopEvt"/>.</summary>
  66 [Efl.Eo.BindingEntity]
  67 public class IDraggableDragStopEvt_Args : EventArgs {
  68     /// <summary>Actual event payload.</summary>
  69     /// <value>Called when drag stopped</value>
  70     public Efl.Object arg { get; set; }
  71 }
  72 /// <summary>Event argument wrapper for event <see cref="Efl.Ui.IDraggable.DragStartUpEvt"/>.</summary>
  73 [Efl.Eo.BindingEntity]
  74 public class IDraggableDragStartUpEvt_Args : EventArgs {
  75     /// <summary>Actual event payload.</summary>
  76     /// <value>Called when drag starts into up direction</value>
  77     public Efl.Object arg { get; set; }
  78 }
  79 /// <summary>Event argument wrapper for event <see cref="Efl.Ui.IDraggable.DragStartDownEvt"/>.</summary>
  80 [Efl.Eo.BindingEntity]
  81 public class IDraggableDragStartDownEvt_Args : EventArgs {
  82     /// <summary>Actual event payload.</summary>
  83     /// <value>Called when drag starts into down direction</value>
  84     public Efl.Object arg { get; set; }
  85 }
  86 /// <summary>Event argument wrapper for event <see cref="Efl.Ui.IDraggable.DragStartRightEvt"/>.</summary>
  87 [Efl.Eo.BindingEntity]
  88 public class IDraggableDragStartRightEvt_Args : EventArgs {
  89     /// <summary>Actual event payload.</summary>
  90     /// <value>Called when drag starts into right direction</value>
  91     public Efl.Object arg { get; set; }
  92 }
  93 /// <summary>Event argument wrapper for event <see cref="Efl.Ui.IDraggable.DragStartLeftEvt"/>.</summary>
  94 [Efl.Eo.BindingEntity]
  95 public class IDraggableDragStartLeftEvt_Args : EventArgs {
  96     /// <summary>Actual event payload.</summary>
  97     /// <value>Called when drag starts into left direction</value>
  98     public Efl.Object arg { get; set; }
  99 }
 100 /// <summary>Efl UI draggable interface</summary>
 101 /// <remarks>This is a <b>BETA</b> class. It can be modified or removed in the future. Do not use it for product development.</remarks>
 102 sealed public  class IDraggableConcrete :
 103     Efl.Eo.EoWrapper
 104     , IDraggable
 105
 106 {
 107     /// <summary>Pointer to the native class description.</summary>
 108     public override System.IntPtr NativeClass
 109     {
 110         get
 111         {
 112             if (((object)this).GetType() == typeof(IDraggableConcrete))
 113             {
 114                 return GetEflClassStatic();
 115             }
 116             else
 117             {
 118                 return Efl.Eo.ClassRegister.klassFromType[((object)this).GetType()];
 119             }
 120         }
 121     }
 122
 123     /// <summary>Subclasses should override this constructor if they are expected to be instantiated from native code.
 124     /// Do not call this constructor directly.</summary>
 125     /// <param name="ch">Tag struct storing the native handle of the object being constructed.</param>
 126     private IDraggableConcrete(ConstructingHandle ch) : base(ch)
 127     {
 128     }
 129
 130     [System.Runtime.InteropServices.DllImport("libefl.so.1")] internal static extern System.IntPtr
 131         efl_ui_draggable_interface_get();
 132     /// <summary>Initializes a new instance of the <see cref="IDraggable"/> class.
 133     /// Internal usage: This is used when interacting with C code and should not be used directly.</summary>
 134     /// <param name="wh">The native pointer to be wrapped.</param>
 135     private IDraggableConcrete(Efl.Eo.Globals.WrappingHandle wh) : base(wh)
 136     {
 137     }
 138
 139     /// <summary>Called when drag operation starts</summary>
 140     /// <value><see cref="Efl.Ui.IDraggableDragEvt_Args"/></value>
 141     public event EventHandler<Efl.Ui.IDraggableDragEvt_Args> DragEvt
 142     {
 143         add
 144         {
 145             lock (eflBindingEventLock)
 146             {
 147                 Efl.EventCb callerCb = (IntPtr data, ref Efl.Event.NativeStruct evt) =>
 148                 {
 149                     var obj = Efl.Eo.Globals.WrapperSupervisorPtrToManaged(data).Target;
 150                     if (obj != null)
 151                     {
 152                         Efl.Ui.IDraggableDragEvt_Args args = new Efl.Ui.IDraggableDragEvt_Args();
 153                         args.arg = (Efl.Eo.Globals.CreateWrapperFor(evt.Info) as Efl.Object);
 154                         try
 155                         {
 156                             value?.Invoke(obj, args);
 157                         }
 158                         catch (Exception e)
 159                         {
 160                             Eina.Log.Error(e.ToString());
 161                             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 162                         }
 163                     }
 164                 };
 165
 166                 string key = "_EFL_UI_EVENT_DRAG";
 167                 AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
 168             }
 169         }
 170
 171         remove
 172         {
 173             lock (eflBindingEventLock)
 174             {
 175                 string key = "_EFL_UI_EVENT_DRAG";
 176                 RemoveNativeEventHandler(efl.Libs.Efl, key, value);
 177             }
 178         }
 179     }
 180     /// <summary>Method to raise event DragEvt.</summary>
 181     public void OnDragEvt(Efl.Ui.IDraggableDragEvt_Args e)
 182     {
 183         var key = "_EFL_UI_EVENT_DRAG";
 184         IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
 185         if (desc == IntPtr.Zero)
 186         {
 187             Eina.Log.Error($"Failed to get native event {key}");
 188             return;
 189         }
 190
 191         IntPtr info = e.arg.NativeHandle;
 192         Efl.Eo.Globals.efl_event_callback_call(this.NativeHandle, desc, info);
 193     }
 194     /// <summary>Called when drag started</summary>
 195     public event EventHandler DragStartEvt
 196     {
 197         add
 198         {
 199             lock (eflBindingEventLock)
 200             {
 201                 Efl.EventCb callerCb = (IntPtr data, ref Efl.Event.NativeStruct evt) =>
 202                 {
 203                     var obj = Efl.Eo.Globals.WrapperSupervisorPtrToManaged(data).Target;
 204                     if (obj != null)
 205                     {
 206                         EventArgs args = EventArgs.Empty;
 207                         try
 208                         {
 209                             value?.Invoke(obj, args);
 210                         }
 211                         catch (Exception e)
 212                         {
 213                             Eina.Log.Error(e.ToString());
 214                             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 215                         }
 216                     }
 217                 };
 218
 219                 string key = "_EFL_UI_EVENT_DRAG_START";
 220                 AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
 221             }
 222         }
 223
 224         remove
 225         {
 226             lock (eflBindingEventLock)
 227             {
 228                 string key = "_EFL_UI_EVENT_DRAG_START";
 229                 RemoveNativeEventHandler(efl.Libs.Efl, key, value);
 230             }
 231         }
 232     }
 233     /// <summary>Method to raise event DragStartEvt.</summary>
 234     public void OnDragStartEvt(EventArgs e)
 235     {
 236         var key = "_EFL_UI_EVENT_DRAG_START";
 237         IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
 238         if (desc == IntPtr.Zero)
 239         {
 240             Eina.Log.Error($"Failed to get native event {key}");
 241             return;
 242         }
 243
 244         Efl.Eo.Globals.efl_event_callback_call(this.NativeHandle, desc, IntPtr.Zero);
 245     }
 246     /// <summary>Called when drag stopped</summary>
 247     /// <value><see cref="Efl.Ui.IDraggableDragStopEvt_Args"/></value>
 248     public event EventHandler<Efl.Ui.IDraggableDragStopEvt_Args> DragStopEvt
 249     {
 250         add
 251         {
 252             lock (eflBindingEventLock)
 253             {
 254                 Efl.EventCb callerCb = (IntPtr data, ref Efl.Event.NativeStruct evt) =>
 255                 {
 256                     var obj = Efl.Eo.Globals.WrapperSupervisorPtrToManaged(data).Target;
 257                     if (obj != null)
 258                     {
 259                         Efl.Ui.IDraggableDragStopEvt_Args args = new Efl.Ui.IDraggableDragStopEvt_Args();
 260                         args.arg = (Efl.Eo.Globals.CreateWrapperFor(evt.Info) as Efl.Object);
 261                         try
 262                         {
 263                             value?.Invoke(obj, args);
 264                         }
 265                         catch (Exception e)
 266                         {
 267                             Eina.Log.Error(e.ToString());
 268                             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 269                         }
 270                     }
 271                 };
 272
 273                 string key = "_EFL_UI_EVENT_DRAG_STOP";
 274                 AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
 275             }
 276         }
 277
 278         remove
 279         {
 280             lock (eflBindingEventLock)
 281             {
 282                 string key = "_EFL_UI_EVENT_DRAG_STOP";
 283                 RemoveNativeEventHandler(efl.Libs.Efl, key, value);
 284             }
 285         }
 286     }
 287     /// <summary>Method to raise event DragStopEvt.</summary>
 288     public void OnDragStopEvt(Efl.Ui.IDraggableDragStopEvt_Args e)
 289     {
 290         var key = "_EFL_UI_EVENT_DRAG_STOP";
 291         IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
 292         if (desc == IntPtr.Zero)
 293         {
 294             Eina.Log.Error($"Failed to get native event {key}");
 295             return;
 296         }
 297
 298         IntPtr info = e.arg.NativeHandle;
 299         Efl.Eo.Globals.efl_event_callback_call(this.NativeHandle, desc, info);
 300     }
 301     /// <summary>Called when drag operation ends</summary>
 302     public event EventHandler DragEndEvt
 303     {
 304         add
 305         {
 306             lock (eflBindingEventLock)
 307             {
 308                 Efl.EventCb callerCb = (IntPtr data, ref Efl.Event.NativeStruct evt) =>
 309                 {
 310                     var obj = Efl.Eo.Globals.WrapperSupervisorPtrToManaged(data).Target;
 311                     if (obj != null)
 312                     {
 313                         EventArgs args = EventArgs.Empty;
 314                         try
 315                         {
 316                             value?.Invoke(obj, args);
 317                         }
 318                         catch (Exception e)
 319                         {
 320                             Eina.Log.Error(e.ToString());
 321                             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 322                         }
 323                     }
 324                 };
 325
 326                 string key = "_EFL_UI_EVENT_DRAG_END";
 327                 AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
 328             }
 329         }
 330
 331         remove
 332         {
 333             lock (eflBindingEventLock)
 334             {
 335                 string key = "_EFL_UI_EVENT_DRAG_END";
 336                 RemoveNativeEventHandler(efl.Libs.Efl, key, value);
 337             }
 338         }
 339     }
 340     /// <summary>Method to raise event DragEndEvt.</summary>
 341     public void OnDragEndEvt(EventArgs e)
 342     {
 343         var key = "_EFL_UI_EVENT_DRAG_END";
 344         IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
 345         if (desc == IntPtr.Zero)
 346         {
 347             Eina.Log.Error($"Failed to get native event {key}");
 348             return;
 349         }
 350
 351         Efl.Eo.Globals.efl_event_callback_call(this.NativeHandle, desc, IntPtr.Zero);
 352     }
 353     /// <summary>Called when drag starts into up direction</summary>
 354     /// <value><see cref="Efl.Ui.IDraggableDragStartUpEvt_Args"/></value>
 355     public event EventHandler<Efl.Ui.IDraggableDragStartUpEvt_Args> DragStartUpEvt
 356     {
 357         add
 358         {
 359             lock (eflBindingEventLock)
 360             {
 361                 Efl.EventCb callerCb = (IntPtr data, ref Efl.Event.NativeStruct evt) =>
 362                 {
 363                     var obj = Efl.Eo.Globals.WrapperSupervisorPtrToManaged(data).Target;
 364                     if (obj != null)
 365                     {
 366                         Efl.Ui.IDraggableDragStartUpEvt_Args args = new Efl.Ui.IDraggableDragStartUpEvt_Args();
 367                         args.arg = (Efl.Eo.Globals.CreateWrapperFor(evt.Info) as Efl.Object);
 368                         try
 369                         {
 370                             value?.Invoke(obj, args);
 371                         }
 372                         catch (Exception e)
 373                         {
 374                             Eina.Log.Error(e.ToString());
 375                             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 376                         }
 377                     }
 378                 };
 379
 380                 string key = "_EFL_UI_EVENT_DRAG_START_UP";
 381                 AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
 382             }
 383         }
 384
 385         remove
 386         {
 387             lock (eflBindingEventLock)
 388             {
 389                 string key = "_EFL_UI_EVENT_DRAG_START_UP";
 390                 RemoveNativeEventHandler(efl.Libs.Efl, key, value);
 391             }
 392         }
 393     }
 394     /// <summary>Method to raise event DragStartUpEvt.</summary>
 395     public void OnDragStartUpEvt(Efl.Ui.IDraggableDragStartUpEvt_Args e)
 396     {
 397         var key = "_EFL_UI_EVENT_DRAG_START_UP";
 398         IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
 399         if (desc == IntPtr.Zero)
 400         {
 401             Eina.Log.Error($"Failed to get native event {key}");
 402             return;
 403         }
 404
 405         IntPtr info = e.arg.NativeHandle;
 406         Efl.Eo.Globals.efl_event_callback_call(this.NativeHandle, desc, info);
 407     }
 408     /// <summary>Called when drag starts into down direction</summary>
 409     /// <value><see cref="Efl.Ui.IDraggableDragStartDownEvt_Args"/></value>
 410     public event EventHandler<Efl.Ui.IDraggableDragStartDownEvt_Args> DragStartDownEvt
 411     {
 412         add
 413         {
 414             lock (eflBindingEventLock)
 415             {
 416                 Efl.EventCb callerCb = (IntPtr data, ref Efl.Event.NativeStruct evt) =>
 417                 {
 418                     var obj = Efl.Eo.Globals.WrapperSupervisorPtrToManaged(data).Target;
 419                     if (obj != null)
 420                     {
 421                         Efl.Ui.IDraggableDragStartDownEvt_Args args = new Efl.Ui.IDraggableDragStartDownEvt_Args();
 422                         args.arg = (Efl.Eo.Globals.CreateWrapperFor(evt.Info) as Efl.Object);
 423                         try
 424                         {
 425                             value?.Invoke(obj, args);
 426                         }
 427                         catch (Exception e)
 428                         {
 429                             Eina.Log.Error(e.ToString());
 430                             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 431                         }
 432                     }
 433                 };
 434
 435                 string key = "_EFL_UI_EVENT_DRAG_START_DOWN";
 436                 AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
 437             }
 438         }
 439
 440         remove
 441         {
 442             lock (eflBindingEventLock)
 443             {
 444                 string key = "_EFL_UI_EVENT_DRAG_START_DOWN";
 445                 RemoveNativeEventHandler(efl.Libs.Efl, key, value);
 446             }
 447         }
 448     }
 449     /// <summary>Method to raise event DragStartDownEvt.</summary>
 450     public void OnDragStartDownEvt(Efl.Ui.IDraggableDragStartDownEvt_Args e)
 451     {
 452         var key = "_EFL_UI_EVENT_DRAG_START_DOWN";
 453         IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
 454         if (desc == IntPtr.Zero)
 455         {
 456             Eina.Log.Error($"Failed to get native event {key}");
 457             return;
 458         }
 459
 460         IntPtr info = e.arg.NativeHandle;
 461         Efl.Eo.Globals.efl_event_callback_call(this.NativeHandle, desc, info);
 462     }
 463     /// <summary>Called when drag starts into right direction</summary>
 464     /// <value><see cref="Efl.Ui.IDraggableDragStartRightEvt_Args"/></value>
 465     public event EventHandler<Efl.Ui.IDraggableDragStartRightEvt_Args> DragStartRightEvt
 466     {
 467         add
 468         {
 469             lock (eflBindingEventLock)
 470             {
 471                 Efl.EventCb callerCb = (IntPtr data, ref Efl.Event.NativeStruct evt) =>
 472                 {
 473                     var obj = Efl.Eo.Globals.WrapperSupervisorPtrToManaged(data).Target;
 474                     if (obj != null)
 475                     {
 476                         Efl.Ui.IDraggableDragStartRightEvt_Args args = new Efl.Ui.IDraggableDragStartRightEvt_Args();
 477                         args.arg = (Efl.Eo.Globals.CreateWrapperFor(evt.Info) as Efl.Object);
 478                         try
 479                         {
 480                             value?.Invoke(obj, args);
 481                         }
 482                         catch (Exception e)
 483                         {
 484                             Eina.Log.Error(e.ToString());
 485                             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 486                         }
 487                     }
 488                 };
 489
 490                 string key = "_EFL_UI_EVENT_DRAG_START_RIGHT";
 491                 AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
 492             }
 493         }
 494
 495         remove
 496         {
 497             lock (eflBindingEventLock)
 498             {
 499                 string key = "_EFL_UI_EVENT_DRAG_START_RIGHT";
 500                 RemoveNativeEventHandler(efl.Libs.Efl, key, value);
 501             }
 502         }
 503     }
 504     /// <summary>Method to raise event DragStartRightEvt.</summary>
 505     public void OnDragStartRightEvt(Efl.Ui.IDraggableDragStartRightEvt_Args e)
 506     {
 507         var key = "_EFL_UI_EVENT_DRAG_START_RIGHT";
 508         IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
 509         if (desc == IntPtr.Zero)
 510         {
 511             Eina.Log.Error($"Failed to get native event {key}");
 512             return;
 513         }
 514
 515         IntPtr info = e.arg.NativeHandle;
 516         Efl.Eo.Globals.efl_event_callback_call(this.NativeHandle, desc, info);
 517     }
 518     /// <summary>Called when drag starts into left direction</summary>
 519     /// <value><see cref="Efl.Ui.IDraggableDragStartLeftEvt_Args"/></value>
 520     public event EventHandler<Efl.Ui.IDraggableDragStartLeftEvt_Args> DragStartLeftEvt
 521     {
 522         add
 523         {
 524             lock (eflBindingEventLock)
 525             {
 526                 Efl.EventCb callerCb = (IntPtr data, ref Efl.Event.NativeStruct evt) =>
 527                 {
 528                     var obj = Efl.Eo.Globals.WrapperSupervisorPtrToManaged(data).Target;
 529                     if (obj != null)
 530                     {
 531                         Efl.Ui.IDraggableDragStartLeftEvt_Args args = new Efl.Ui.IDraggableDragStartLeftEvt_Args();
 532                         args.arg = (Efl.Eo.Globals.CreateWrapperFor(evt.Info) as Efl.Object);
 533                         try
 534                         {
 535                             value?.Invoke(obj, args);
 536                         }
 537                         catch (Exception e)
 538                         {
 539                             Eina.Log.Error(e.ToString());
 540                             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 541                         }
 542                     }
 543                 };
 544
 545                 string key = "_EFL_UI_EVENT_DRAG_START_LEFT";
 546                 AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
 547             }
 548         }
 549
 550         remove
 551         {
 552             lock (eflBindingEventLock)
 553             {
 554                 string key = "_EFL_UI_EVENT_DRAG_START_LEFT";
 555                 RemoveNativeEventHandler(efl.Libs.Efl, key, value);
 556             }
 557         }
 558     }
 559     /// <summary>Method to raise event DragStartLeftEvt.</summary>
 560     public void OnDragStartLeftEvt(Efl.Ui.IDraggableDragStartLeftEvt_Args e)
 561     {
 562         var key = "_EFL_UI_EVENT_DRAG_START_LEFT";
 563         IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
 564         if (desc == IntPtr.Zero)
 565         {
 566             Eina.Log.Error($"Failed to get native event {key}");
 567             return;
 568         }
 569
 570         IntPtr info = e.arg.NativeHandle;
 571         Efl.Eo.Globals.efl_event_callback_call(this.NativeHandle, desc, info);
 572     }
 573     /// <summary>Control whether the object&apos;s content is changed by drag and drop.
 574     /// If <c>drag_target</c> is true the object can be the target of a dragging object. The content of this object can then be changed into dragging content. For example, if an object deals with image and <c>drag_target</c> is true, the user can drag the new image and drop it into said object. This object&apos;s image can then be changed into a new image.</summary>
 575     /// <returns>Turn on or off drop_target. Default is <c>false</c>.</returns>
 576     public bool GetDragTarget() {
 577          var _ret_var = Efl.Ui.IDraggableConcrete.NativeMethods.efl_ui_draggable_drag_target_get_ptr.Value.Delegate(this.NativeHandle);
 578         Eina.Error.RaiseIfUnhandledException();
 579         return _ret_var;
 580  }
 581     /// <summary>Control whether the object&apos;s content is changed by drag and drop.
 582     /// If <c>drag_target</c> is true the object can be the target of a dragging object. The content of this object can then be changed into dragging content. For example, if an object deals with image and <c>drag_target</c> is true, the user can drag the new image and drop it into said object. This object&apos;s image can then be changed into a new image.</summary>
 583     /// <param name="set">Turn on or off drop_target. Default is <c>false</c>.</param>
 584     public void SetDragTarget(bool set) {
 585                                  Efl.Ui.IDraggableConcrete.NativeMethods.efl_ui_draggable_drag_target_set_ptr.Value.Delegate(this.NativeHandle,set);
 586         Eina.Error.RaiseIfUnhandledException();
 587                          }
 588     /// <summary>Control whether the object&apos;s content is changed by drag and drop.
 589     /// If <c>drag_target</c> is true the object can be the target of a dragging object. The content of this object can then be changed into dragging content. For example, if an object deals with image and <c>drag_target</c> is true, the user can drag the new image and drop it into said object. This object&apos;s image can then be changed into a new image.</summary>
 590     /// <value>Turn on or off drop_target. Default is <c>false</c>.</value>
 591     public bool DragTarget {
 592         get { return GetDragTarget(); }
 593         set { SetDragTarget(value); }
 594     }
 595     private static IntPtr GetEflClassStatic()
 596     {
 597         return Efl.Ui.IDraggableConcrete.efl_ui_draggable_interface_get();
 598     }
 599     /// <summary>Wrapper for native methods and virtual method delegates.
 600     /// For internal use by generated code only.</summary>
 601     public new class NativeMethods : Efl.Eo.EoWrapper.NativeMethods
 602     {
 603         private static Efl.Eo.NativeModule Module = new Efl.Eo.NativeModule(    efl.Libs.Efl);
 604         /// <summary>Gets the list of Eo operations to override.</summary>
 605         /// <returns>The list of Eo operations to be overload.</returns>
 606         public override System.Collections.Generic.List<Efl_Op_Description> GetEoOps(System.Type type)
 607         {
 608             var descs = new System.Collections.Generic.List<Efl_Op_Description>();
 609             var methods = Efl.Eo.Globals.GetUserMethods(type);
 610
 611             if (efl_ui_draggable_drag_target_get_static_delegate == null)
 612             {
 613                 efl_ui_draggable_drag_target_get_static_delegate = new efl_ui_draggable_drag_target_get_delegate(drag_target_get);
 614             }
 615
 616             if (methods.FirstOrDefault(m => m.Name == "GetDragTarget") != null)
 617             {
 618                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_ui_draggable_drag_target_get"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_draggable_drag_target_get_static_delegate) });
 619             }
 620
 621             if (efl_ui_draggable_drag_target_set_static_delegate == null)
 622             {
 623                 efl_ui_draggable_drag_target_set_static_delegate = new efl_ui_draggable_drag_target_set_delegate(drag_target_set);
 624             }
 625
 626             if (methods.FirstOrDefault(m => m.Name == "SetDragTarget") != null)
 627             {
 628                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_ui_draggable_drag_target_set"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_draggable_drag_target_set_static_delegate) });
 629             }
 630
 631             return descs;
 632         }
 633         /// <summary>Returns the Eo class for the native methods of this class.</summary>
 634         /// <returns>The native class pointer.</returns>
 635         public override IntPtr GetEflClass()
 636         {
 637             return Efl.Ui.IDraggableConcrete.efl_ui_draggable_interface_get();
 638         }
 639
 640         #pragma warning disable CA1707, CS1591, SA1300, SA1600
 641
 642         [return: MarshalAs(UnmanagedType.U1)]
 643         private delegate bool efl_ui_draggable_drag_target_get_delegate(System.IntPtr obj, System.IntPtr pd);
 644
 645         [return: MarshalAs(UnmanagedType.U1)]
 646         public delegate bool efl_ui_draggable_drag_target_get_api_delegate(System.IntPtr obj);
 647
 648         public static Efl.Eo.FunctionWrapper<efl_ui_draggable_drag_target_get_api_delegate> efl_ui_draggable_drag_target_get_ptr = new Efl.Eo.FunctionWrapper<efl_ui_draggable_drag_target_get_api_delegate>(Module, "efl_ui_draggable_drag_target_get");
 649
 650         private static bool drag_target_get(System.IntPtr obj, System.IntPtr pd)
 651         {
 652             Eina.Log.Debug("function efl_ui_draggable_drag_target_get was called");
 653             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 654             if (ws != null)
 655             {
 656             bool _ret_var = default(bool);
 657                 try
 658                 {
 659                     _ret_var = ((IDraggable)ws.Target).GetDragTarget();
 660                 }
 661                 catch (Exception e)
 662                 {
 663                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 664                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 665                 }
 666
 667         return _ret_var;
 668
 669             }
 670             else
 671             {
 672                 return efl_ui_draggable_drag_target_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
 673             }
 674         }
 675
 676         private static efl_ui_draggable_drag_target_get_delegate efl_ui_draggable_drag_target_get_static_delegate;
 677
 678
 679         private delegate void efl_ui_draggable_drag_target_set_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.U1)] bool set);
 680
 681
 682         public delegate void efl_ui_draggable_drag_target_set_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.U1)] bool set);
 683
 684         public static Efl.Eo.FunctionWrapper<efl_ui_draggable_drag_target_set_api_delegate> efl_ui_draggable_drag_target_set_ptr = new Efl.Eo.FunctionWrapper<efl_ui_draggable_drag_target_set_api_delegate>(Module, "efl_ui_draggable_drag_target_set");
 685
 686         private static void drag_target_set(System.IntPtr obj, System.IntPtr pd, bool set)
 687         {
 688             Eina.Log.Debug("function efl_ui_draggable_drag_target_set was called");
 689             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 690             if (ws != null)
 691             {
 692
 693                 try
 694                 {
 695                     ((IDraggable)ws.Target).SetDragTarget(set);
 696                 }
 697                 catch (Exception e)
 698                 {
 699                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 700                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 701                 }
 702
 703
 704             }
 705             else
 706             {
 707                 efl_ui_draggable_drag_target_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), set);
 708             }
 709         }
 710
 711         private static efl_ui_draggable_drag_target_set_delegate efl_ui_draggable_drag_target_set_static_delegate;
 712
 713         #pragma warning restore CA1707, CS1591, SA1300, SA1600
 714
 715 }
 716 }
 717 }
 718
 719 }
 720
 721 #if EFL_BETA
 722 #pragma warning disable CS1591
 723 public static class Efl_UiIDraggableConcrete_ExtensionMethods {
 724     public static Efl.BindableProperty<bool> DragTarget<T>(this Efl.Ui.ItemFactory<T> fac, Efl.Csharp.ExtensionTag<Efl.Ui.IDraggable, T>magic = null) where T : Efl.Ui.IDraggable {
 725         return new Efl.BindableProperty<bool>("drag_target", fac);
 726     }
 727
 728 }
 729 #pragma warning restore CS1591
 730 #endif