internals/src/EflSharp/EflSharp/efl/efl_ui_selectable.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 selectable interface</summary>
  13 [Efl.Ui.ISelectableConcrete.NativeMethods]
  14 public interface ISelectable :
  15     Efl.Eo.IWrapper, IDisposable
  16 {
  17     /// <summary>Called when selected</summary>
  18     event EventHandler<Efl.Ui.ISelectableItemSelectedEvt_Args> ItemSelectedEvt;
  19     /// <summary>Called when no longer selected</summary>
  20     event EventHandler<Efl.Ui.ISelectableItemUnselectedEvt_Args> ItemUnselectedEvt;
  21     /// <summary>Called when selection is pasted</summary>
  22     event EventHandler SelectionPasteEvt;
  23     /// <summary>Called when selection is copied</summary>
  24     event EventHandler SelectionCopyEvt;
  25     /// <summary>Called when selection is cut</summary>
  26     event EventHandler SelectionCutEvt;
  27     /// <summary>Called at selection start</summary>
  28     event EventHandler SelectionStartEvt;
  29     /// <summary>Called when selection is changed</summary>
  30     event EventHandler SelectionChangedEvt;
  31     /// <summary>Called when selection is cleared</summary>
  32     event EventHandler SelectionClearedEvt;
  33 }
  34 ///<summary>Event argument wrapper for event <see cref="Efl.Ui.ISelectable.ItemSelectedEvt"/>.</summary>
  35 public class ISelectableItemSelectedEvt_Args : EventArgs {
  36     ///<summary>Actual event payload.</summary>
  37     public Efl.Object arg { get; set; }
  38 }
  39 ///<summary>Event argument wrapper for event <see cref="Efl.Ui.ISelectable.ItemUnselectedEvt"/>.</summary>
  40 public class ISelectableItemUnselectedEvt_Args : EventArgs {
  41     ///<summary>Actual event payload.</summary>
  42     public Efl.Object arg { get; set; }
  43 }
  44 /// <summary>Efl UI selectable interface</summary>
  45 sealed public class ISelectableConcrete :
  46     Efl.Eo.EoWrapper
  47     , ISelectable
  48
  49 {
  50     ///<summary>Pointer to the native class description.</summary>
  51     public override System.IntPtr NativeClass
  52     {
  53         get
  54         {
  55             if (((object)this).GetType() == typeof(ISelectableConcrete))
  56             {
  57                 return GetEflClassStatic();
  58             }
  59             else
  60             {
  61                 return Efl.Eo.ClassRegister.klassFromType[((object)this).GetType()];
  62             }
  63         }
  64     }
  65
  66     [System.Runtime.InteropServices.DllImport(efl.Libs.Efl)] internal static extern System.IntPtr
  67         efl_ui_selectable_interface_get();
  68     /// <summary>Initializes a new instance of the <see cref="ISelectable"/> class.
  69     /// Internal usage: This is used when interacting with C code and should not be used directly.</summary>
  70     private ISelectableConcrete(System.IntPtr raw) : base(raw)
  71     {
  72     }
  73
  74     /// <summary>Called when selected</summary>
  75     public event EventHandler<Efl.Ui.ISelectableItemSelectedEvt_Args> ItemSelectedEvt
  76     {
  77         add
  78         {
  79             lock (eventLock)
  80             {
  81                 Efl.EventCb callerCb = (IntPtr data, ref Efl.Event.NativeStruct evt) =>
  82                 {
  83                     var obj = Efl.Eo.Globals.WrapperSupervisorPtrToManaged(data).Target;
  84                     if (obj != null)
  85                     {
  86                         Efl.Ui.ISelectableItemSelectedEvt_Args args = new Efl.Ui.ISelectableItemSelectedEvt_Args();
  87                         args.arg = (Efl.Eo.Globals.CreateWrapperFor(evt.Info) as Efl.Object);
  88                         try
  89                         {
  90                             value?.Invoke(obj, args);
  91                         }
  92                         catch (Exception e)
  93                         {
  94                             Eina.Log.Error(e.ToString());
  95                             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
  96                         }
  97                     }
  98                 };
  99
 100                 string key = "_EFL_UI_EVENT_ITEM_SELECTED";
 101                 AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
 102             }
 103         }
 104
 105         remove
 106         {
 107             lock (eventLock)
 108             {
 109                 string key = "_EFL_UI_EVENT_ITEM_SELECTED";
 110                 RemoveNativeEventHandler(efl.Libs.Efl, key, value);
 111             }
 112         }
 113     }
 114     ///<summary>Method to raise event ItemSelectedEvt.</summary>
 115     public void OnItemSelectedEvt(Efl.Ui.ISelectableItemSelectedEvt_Args e)
 116     {
 117         var key = "_EFL_UI_EVENT_ITEM_SELECTED";
 118         IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
 119         if (desc == IntPtr.Zero)
 120         {
 121             Eina.Log.Error($"Failed to get native event {key}");
 122             return;
 123         }
 124
 125         IntPtr info = e.arg.NativeHandle;
 126         Efl.Eo.Globals.efl_event_callback_call(this.NativeHandle, desc, info);
 127     }
 128     /// <summary>Called when no longer selected</summary>
 129     public event EventHandler<Efl.Ui.ISelectableItemUnselectedEvt_Args> ItemUnselectedEvt
 130     {
 131         add
 132         {
 133             lock (eventLock)
 134             {
 135                 Efl.EventCb callerCb = (IntPtr data, ref Efl.Event.NativeStruct evt) =>
 136                 {
 137                     var obj = Efl.Eo.Globals.WrapperSupervisorPtrToManaged(data).Target;
 138                     if (obj != null)
 139                     {
 140                         Efl.Ui.ISelectableItemUnselectedEvt_Args args = new Efl.Ui.ISelectableItemUnselectedEvt_Args();
 141                         args.arg = (Efl.Eo.Globals.CreateWrapperFor(evt.Info) as Efl.Object);
 142                         try
 143                         {
 144                             value?.Invoke(obj, args);
 145                         }
 146                         catch (Exception e)
 147                         {
 148                             Eina.Log.Error(e.ToString());
 149                             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 150                         }
 151                     }
 152                 };
 153
 154                 string key = "_EFL_UI_EVENT_ITEM_UNSELECTED";
 155                 AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
 156             }
 157         }
 158
 159         remove
 160         {
 161             lock (eventLock)
 162             {
 163                 string key = "_EFL_UI_EVENT_ITEM_UNSELECTED";
 164                 RemoveNativeEventHandler(efl.Libs.Efl, key, value);
 165             }
 166         }
 167     }
 168     ///<summary>Method to raise event ItemUnselectedEvt.</summary>
 169     public void OnItemUnselectedEvt(Efl.Ui.ISelectableItemUnselectedEvt_Args e)
 170     {
 171         var key = "_EFL_UI_EVENT_ITEM_UNSELECTED";
 172         IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
 173         if (desc == IntPtr.Zero)
 174         {
 175             Eina.Log.Error($"Failed to get native event {key}");
 176             return;
 177         }
 178
 179         IntPtr info = e.arg.NativeHandle;
 180         Efl.Eo.Globals.efl_event_callback_call(this.NativeHandle, desc, info);
 181     }
 182     /// <summary>Called when selection is pasted</summary>
 183     public event EventHandler SelectionPasteEvt
 184     {
 185         add
 186         {
 187             lock (eventLock)
 188             {
 189                 Efl.EventCb callerCb = (IntPtr data, ref Efl.Event.NativeStruct evt) =>
 190                 {
 191                     var obj = Efl.Eo.Globals.WrapperSupervisorPtrToManaged(data).Target;
 192                     if (obj != null)
 193                     {
 194                         EventArgs args = EventArgs.Empty;
 195                         try
 196                         {
 197                             value?.Invoke(obj, args);
 198                         }
 199                         catch (Exception e)
 200                         {
 201                             Eina.Log.Error(e.ToString());
 202                             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 203                         }
 204                     }
 205                 };
 206
 207                 string key = "_EFL_UI_EVENT_SELECTION_PASTE";
 208                 AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
 209             }
 210         }
 211
 212         remove
 213         {
 214             lock (eventLock)
 215             {
 216                 string key = "_EFL_UI_EVENT_SELECTION_PASTE";
 217                 RemoveNativeEventHandler(efl.Libs.Efl, key, value);
 218             }
 219         }
 220     }
 221     ///<summary>Method to raise event SelectionPasteEvt.</summary>
 222     public void OnSelectionPasteEvt(EventArgs e)
 223     {
 224         var key = "_EFL_UI_EVENT_SELECTION_PASTE";
 225         IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
 226         if (desc == IntPtr.Zero)
 227         {
 228             Eina.Log.Error($"Failed to get native event {key}");
 229             return;
 230         }
 231
 232         Efl.Eo.Globals.efl_event_callback_call(this.NativeHandle, desc, IntPtr.Zero);
 233     }
 234     /// <summary>Called when selection is copied</summary>
 235     public event EventHandler SelectionCopyEvt
 236     {
 237         add
 238         {
 239             lock (eventLock)
 240             {
 241                 Efl.EventCb callerCb = (IntPtr data, ref Efl.Event.NativeStruct evt) =>
 242                 {
 243                     var obj = Efl.Eo.Globals.WrapperSupervisorPtrToManaged(data).Target;
 244                     if (obj != null)
 245                     {
 246                         EventArgs args = EventArgs.Empty;
 247                         try
 248                         {
 249                             value?.Invoke(obj, args);
 250                         }
 251                         catch (Exception e)
 252                         {
 253                             Eina.Log.Error(e.ToString());
 254                             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 255                         }
 256                     }
 257                 };
 258
 259                 string key = "_EFL_UI_EVENT_SELECTION_COPY";
 260                 AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
 261             }
 262         }
 263
 264         remove
 265         {
 266             lock (eventLock)
 267             {
 268                 string key = "_EFL_UI_EVENT_SELECTION_COPY";
 269                 RemoveNativeEventHandler(efl.Libs.Efl, key, value);
 270             }
 271         }
 272     }
 273     ///<summary>Method to raise event SelectionCopyEvt.</summary>
 274     public void OnSelectionCopyEvt(EventArgs e)
 275     {
 276         var key = "_EFL_UI_EVENT_SELECTION_COPY";
 277         IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
 278         if (desc == IntPtr.Zero)
 279         {
 280             Eina.Log.Error($"Failed to get native event {key}");
 281             return;
 282         }
 283
 284         Efl.Eo.Globals.efl_event_callback_call(this.NativeHandle, desc, IntPtr.Zero);
 285     }
 286     /// <summary>Called when selection is cut</summary>
 287     public event EventHandler SelectionCutEvt
 288     {
 289         add
 290         {
 291             lock (eventLock)
 292             {
 293                 Efl.EventCb callerCb = (IntPtr data, ref Efl.Event.NativeStruct evt) =>
 294                 {
 295                     var obj = Efl.Eo.Globals.WrapperSupervisorPtrToManaged(data).Target;
 296                     if (obj != null)
 297                     {
 298                         EventArgs args = EventArgs.Empty;
 299                         try
 300                         {
 301                             value?.Invoke(obj, args);
 302                         }
 303                         catch (Exception e)
 304                         {
 305                             Eina.Log.Error(e.ToString());
 306                             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 307                         }
 308                     }
 309                 };
 310
 311                 string key = "_EFL_UI_EVENT_SELECTION_CUT";
 312                 AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
 313             }
 314         }
 315
 316         remove
 317         {
 318             lock (eventLock)
 319             {
 320                 string key = "_EFL_UI_EVENT_SELECTION_CUT";
 321                 RemoveNativeEventHandler(efl.Libs.Efl, key, value);
 322             }
 323         }
 324     }
 325     ///<summary>Method to raise event SelectionCutEvt.</summary>
 326     public void OnSelectionCutEvt(EventArgs e)
 327     {
 328         var key = "_EFL_UI_EVENT_SELECTION_CUT";
 329         IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
 330         if (desc == IntPtr.Zero)
 331         {
 332             Eina.Log.Error($"Failed to get native event {key}");
 333             return;
 334         }
 335
 336         Efl.Eo.Globals.efl_event_callback_call(this.NativeHandle, desc, IntPtr.Zero);
 337     }
 338     /// <summary>Called at selection start</summary>
 339     public event EventHandler SelectionStartEvt
 340     {
 341         add
 342         {
 343             lock (eventLock)
 344             {
 345                 Efl.EventCb callerCb = (IntPtr data, ref Efl.Event.NativeStruct evt) =>
 346                 {
 347                     var obj = Efl.Eo.Globals.WrapperSupervisorPtrToManaged(data).Target;
 348                     if (obj != null)
 349                     {
 350                         EventArgs args = EventArgs.Empty;
 351                         try
 352                         {
 353                             value?.Invoke(obj, args);
 354                         }
 355                         catch (Exception e)
 356                         {
 357                             Eina.Log.Error(e.ToString());
 358                             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 359                         }
 360                     }
 361                 };
 362
 363                 string key = "_EFL_UI_EVENT_SELECTION_START";
 364                 AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
 365             }
 366         }
 367
 368         remove
 369         {
 370             lock (eventLock)
 371             {
 372                 string key = "_EFL_UI_EVENT_SELECTION_START";
 373                 RemoveNativeEventHandler(efl.Libs.Efl, key, value);
 374             }
 375         }
 376     }
 377     ///<summary>Method to raise event SelectionStartEvt.</summary>
 378     public void OnSelectionStartEvt(EventArgs e)
 379     {
 380         var key = "_EFL_UI_EVENT_SELECTION_START";
 381         IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
 382         if (desc == IntPtr.Zero)
 383         {
 384             Eina.Log.Error($"Failed to get native event {key}");
 385             return;
 386         }
 387
 388         Efl.Eo.Globals.efl_event_callback_call(this.NativeHandle, desc, IntPtr.Zero);
 389     }
 390     /// <summary>Called when selection is changed</summary>
 391     public event EventHandler SelectionChangedEvt
 392     {
 393         add
 394         {
 395             lock (eventLock)
 396             {
 397                 Efl.EventCb callerCb = (IntPtr data, ref Efl.Event.NativeStruct evt) =>
 398                 {
 399                     var obj = Efl.Eo.Globals.WrapperSupervisorPtrToManaged(data).Target;
 400                     if (obj != null)
 401                     {
 402                         EventArgs args = EventArgs.Empty;
 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_SELECTION_CHANGED";
 416                 AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
 417             }
 418         }
 419
 420         remove
 421         {
 422             lock (eventLock)
 423             {
 424                 string key = "_EFL_UI_EVENT_SELECTION_CHANGED";
 425                 RemoveNativeEventHandler(efl.Libs.Efl, key, value);
 426             }
 427         }
 428     }
 429     ///<summary>Method to raise event SelectionChangedEvt.</summary>
 430     public void OnSelectionChangedEvt(EventArgs e)
 431     {
 432         var key = "_EFL_UI_EVENT_SELECTION_CHANGED";
 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         Efl.Eo.Globals.efl_event_callback_call(this.NativeHandle, desc, IntPtr.Zero);
 441     }
 442     /// <summary>Called when selection is cleared</summary>
 443     public event EventHandler SelectionClearedEvt
 444     {
 445         add
 446         {
 447             lock (eventLock)
 448             {
 449                 Efl.EventCb callerCb = (IntPtr data, ref Efl.Event.NativeStruct evt) =>
 450                 {
 451                     var obj = Efl.Eo.Globals.WrapperSupervisorPtrToManaged(data).Target;
 452                     if (obj != null)
 453                     {
 454                         EventArgs args = EventArgs.Empty;
 455                         try
 456                         {
 457                             value?.Invoke(obj, args);
 458                         }
 459                         catch (Exception e)
 460                         {
 461                             Eina.Log.Error(e.ToString());
 462                             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 463                         }
 464                     }
 465                 };
 466
 467                 string key = "_EFL_UI_EVENT_SELECTION_CLEARED";
 468                 AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
 469             }
 470         }
 471
 472         remove
 473         {
 474             lock (eventLock)
 475             {
 476                 string key = "_EFL_UI_EVENT_SELECTION_CLEARED";
 477                 RemoveNativeEventHandler(efl.Libs.Efl, key, value);
 478             }
 479         }
 480     }
 481     ///<summary>Method to raise event SelectionClearedEvt.</summary>
 482     public void OnSelectionClearedEvt(EventArgs e)
 483     {
 484         var key = "_EFL_UI_EVENT_SELECTION_CLEARED";
 485         IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
 486         if (desc == IntPtr.Zero)
 487         {
 488             Eina.Log.Error($"Failed to get native event {key}");
 489             return;
 490         }
 491
 492         Efl.Eo.Globals.efl_event_callback_call(this.NativeHandle, desc, IntPtr.Zero);
 493     }
 494     private static IntPtr GetEflClassStatic()
 495     {
 496         return Efl.Ui.ISelectableConcrete.efl_ui_selectable_interface_get();
 497     }
 498     /// <summary>Wrapper for native methods and virtual method delegates.
 499     /// For internal use by generated code only.</summary>
 500     public class NativeMethods  : Efl.Eo.NativeClass
 501     {
 502         /// <summary>Gets the list of Eo operations to override.</summary>
 503         /// <returns>The list of Eo operations to be overload.</returns>
 504         public override System.Collections.Generic.List<Efl_Op_Description> GetEoOps(System.Type type)
 505         {
 506             var descs = new System.Collections.Generic.List<Efl_Op_Description>();
 507             return descs;
 508         }
 509         /// <summary>Returns the Eo class for the native methods of this class.</summary>
 510         /// <returns>The native class pointer.</returns>
 511         public override IntPtr GetEflClass()
 512         {
 513             return Efl.Ui.ISelectableConcrete.efl_ui_selectable_interface_get();
 514         }
 515
 516         #pragma warning disable CA1707, CS1591, SA1300, SA1600
 517
 518         #pragma warning restore CA1707, CS1591, SA1300, SA1600
 519
 520 }
 521 }
 522 }
 523
 524 }
 525