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