internals/src/EflSharp/EflSharp/efl_ui_item.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.ComponentModel;
   7 namespace Efl { namespace Ui {
   8 /// <summary>Item abstract class for pack widget. All item have to be inherited from this class.</summary>
   9 [ItemNativeInherit]
  10 public class Item : Efl.Ui.LayoutBase, Efl.Eo.IWrapper,Efl.Ui.Clickable,Efl.Ui.Selectable
  11 {
  12    public new static System.IntPtr klass = System.IntPtr.Zero;
  13    public new static Efl.Ui.ItemNativeInherit nativeInherit = new Efl.Ui.ItemNativeInherit();
  14    ///<summary>Pointer to the native class description.</summary>
  15    public override System.IntPtr NativeClass {
  16       get {
  17          if (((object)this).GetType() == typeof (Item))
  18             return Efl.Ui.ItemNativeInherit.GetEflClassStatic();
  19          else
  20             return Efl.Eo.ClassRegister.klassFromType[((object)this).GetType()];
  21       }
  22    }
  23    [System.Runtime.InteropServices.DllImport(efl.Libs.Elementary)] internal static extern System.IntPtr
  24       efl_ui_item_class_get();
  25    ///<summary>Creates a new instance.</summary>
  26    ///<param name="parent">Parent instance.</param>
  27    ///<param name="style">The widget style to use. See <see cref="Efl.Ui.Widget.SetStyle"/></param>
  28    public Item(Efl.Object parent
  29          ,  System.String style = null) :
  30       base(efl_ui_item_class_get(), typeof(Item), parent)
  31    {
  32       if (Efl.Eo.Globals.ParamHelperCheck(style))
  33          SetStyle(Efl.Eo.Globals.GetParamHelper(style));
  34       FinishInstantiation();
  35    }
  36    ///<summary>Internal usage: Constructs an instance from a native pointer. This is used when interacting with C code and should not be used directly.</summary>
  37    public Item(System.IntPtr raw) : base(raw)
  38    {
  39             register_event_proxies();
  40    }
  41    ///<summary>Internal usage: Constructor to forward the wrapper initialization to the root class that interfaces with native code. Should not be used directly.</summary>
  42    protected Item(IntPtr base_klass, System.Type managed_type, Efl.Object parent) : base(base_klass, managed_type, parent) {}
  43    ///<summary>Casts obj into an instance of this type.</summary>
  44    public new static Item static_cast(Efl.Object obj)
  45    {
  46       if (obj == null)
  47          throw new System.ArgumentNullException("obj");
  48       return new Item(obj.NativeHandle);
  49    }
  50    ///<summary>Verifies if the given object is equal to this one.</summary>
  51    public override bool Equals(object obj)
  52    {
  53       var other = obj as Efl.Object;
  54       if (other == null)
  55          return false;
  56       return this.NativeHandle == other.NativeHandle;
  57    }
  58    ///<summary>Gets the hash code for this object based on the native pointer it points to.</summary>
  59    public override int GetHashCode()
  60    {
  61       return this.NativeHandle.ToInt32();
  62    }
  63    ///<summary>Turns the native pointer into a string representation.</summary>
  64    public override String ToString()
  65    {
  66       return $"{this.GetType().Name}@[{this.NativeHandle.ToInt32():x}]";
  67    }
  68 private static object ClickedEvtKey = new object();
  69    /// <summary>Called when object is clicked</summary>
  70    public event EventHandler ClickedEvt
  71    {
  72       add {
  73          lock (eventLock) {
  74             string key = "_EFL_UI_EVENT_CLICKED";
  75             if (add_cpp_event_handler(efl.Libs.Efl, key, this.evt_ClickedEvt_delegate)) {
  76                eventHandlers.AddHandler(ClickedEvtKey , value);
  77             } else
  78                Eina.Log.Error($"Error adding proxy for event {key}");
  79          }
  80       }
  81       remove {
  82          lock (eventLock) {
  83             string key = "_EFL_UI_EVENT_CLICKED";
  84             if (remove_cpp_event_handler(key, this.evt_ClickedEvt_delegate)) {
  85                eventHandlers.RemoveHandler(ClickedEvtKey , value);
  86             } else
  87                Eina.Log.Error($"Error removing proxy for event {key}");
  88          }
  89       }
  90    }
  91    ///<summary>Method to raise event ClickedEvt.</summary>
  92    public void On_ClickedEvt(EventArgs e)
  93    {
  94       EventHandler evt;
  95       lock (eventLock) {
  96       evt = (EventHandler)eventHandlers[ClickedEvtKey];
  97       }
  98       evt?.Invoke(this, e);
  99    }
 100    Efl.EventCb evt_ClickedEvt_delegate;
 101    private void on_ClickedEvt_NativeCallback(System.IntPtr data, ref Efl.Event_StructInternal evt)
 102    {
 103       EventArgs args = EventArgs.Empty;
 104       try {
 105          On_ClickedEvt(args);
 106       } catch (Exception e) {
 107          Eina.Log.Error(e.ToString());
 108          Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 109       }
 110    }
 111
 112 private static object ClickedDoubleEvtKey = new object();
 113    /// <summary>Called when object receives a double click</summary>
 114    public event EventHandler ClickedDoubleEvt
 115    {
 116       add {
 117          lock (eventLock) {
 118             string key = "_EFL_UI_EVENT_CLICKED_DOUBLE";
 119             if (add_cpp_event_handler(efl.Libs.Efl, key, this.evt_ClickedDoubleEvt_delegate)) {
 120                eventHandlers.AddHandler(ClickedDoubleEvtKey , value);
 121             } else
 122                Eina.Log.Error($"Error adding proxy for event {key}");
 123          }
 124       }
 125       remove {
 126          lock (eventLock) {
 127             string key = "_EFL_UI_EVENT_CLICKED_DOUBLE";
 128             if (remove_cpp_event_handler(key, this.evt_ClickedDoubleEvt_delegate)) {
 129                eventHandlers.RemoveHandler(ClickedDoubleEvtKey , value);
 130             } else
 131                Eina.Log.Error($"Error removing proxy for event {key}");
 132          }
 133       }
 134    }
 135    ///<summary>Method to raise event ClickedDoubleEvt.</summary>
 136    public void On_ClickedDoubleEvt(EventArgs e)
 137    {
 138       EventHandler evt;
 139       lock (eventLock) {
 140       evt = (EventHandler)eventHandlers[ClickedDoubleEvtKey];
 141       }
 142       evt?.Invoke(this, e);
 143    }
 144    Efl.EventCb evt_ClickedDoubleEvt_delegate;
 145    private void on_ClickedDoubleEvt_NativeCallback(System.IntPtr data, ref Efl.Event_StructInternal evt)
 146    {
 147       EventArgs args = EventArgs.Empty;
 148       try {
 149          On_ClickedDoubleEvt(args);
 150       } catch (Exception e) {
 151          Eina.Log.Error(e.ToString());
 152          Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 153       }
 154    }
 155
 156 private static object ClickedTripleEvtKey = new object();
 157    /// <summary>Called when object receives a triple click</summary>
 158    public event EventHandler ClickedTripleEvt
 159    {
 160       add {
 161          lock (eventLock) {
 162             string key = "_EFL_UI_EVENT_CLICKED_TRIPLE";
 163             if (add_cpp_event_handler(efl.Libs.Efl, key, this.evt_ClickedTripleEvt_delegate)) {
 164                eventHandlers.AddHandler(ClickedTripleEvtKey , value);
 165             } else
 166                Eina.Log.Error($"Error adding proxy for event {key}");
 167          }
 168       }
 169       remove {
 170          lock (eventLock) {
 171             string key = "_EFL_UI_EVENT_CLICKED_TRIPLE";
 172             if (remove_cpp_event_handler(key, this.evt_ClickedTripleEvt_delegate)) {
 173                eventHandlers.RemoveHandler(ClickedTripleEvtKey , value);
 174             } else
 175                Eina.Log.Error($"Error removing proxy for event {key}");
 176          }
 177       }
 178    }
 179    ///<summary>Method to raise event ClickedTripleEvt.</summary>
 180    public void On_ClickedTripleEvt(EventArgs e)
 181    {
 182       EventHandler evt;
 183       lock (eventLock) {
 184       evt = (EventHandler)eventHandlers[ClickedTripleEvtKey];
 185       }
 186       evt?.Invoke(this, e);
 187    }
 188    Efl.EventCb evt_ClickedTripleEvt_delegate;
 189    private void on_ClickedTripleEvt_NativeCallback(System.IntPtr data, ref Efl.Event_StructInternal evt)
 190    {
 191       EventArgs args = EventArgs.Empty;
 192       try {
 193          On_ClickedTripleEvt(args);
 194       } catch (Exception e) {
 195          Eina.Log.Error(e.ToString());
 196          Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 197       }
 198    }
 199
 200 private static object ClickedRightEvtKey = new object();
 201    /// <summary>Called when object receives a right click</summary>
 202    public event EventHandler<Efl.Ui.ClickableClickedRightEvt_Args> ClickedRightEvt
 203    {
 204       add {
 205          lock (eventLock) {
 206             string key = "_EFL_UI_EVENT_CLICKED_RIGHT";
 207             if (add_cpp_event_handler(efl.Libs.Efl, key, this.evt_ClickedRightEvt_delegate)) {
 208                eventHandlers.AddHandler(ClickedRightEvtKey , value);
 209             } else
 210                Eina.Log.Error($"Error adding proxy for event {key}");
 211          }
 212       }
 213       remove {
 214          lock (eventLock) {
 215             string key = "_EFL_UI_EVENT_CLICKED_RIGHT";
 216             if (remove_cpp_event_handler(key, this.evt_ClickedRightEvt_delegate)) {
 217                eventHandlers.RemoveHandler(ClickedRightEvtKey , value);
 218             } else
 219                Eina.Log.Error($"Error removing proxy for event {key}");
 220          }
 221       }
 222    }
 223    ///<summary>Method to raise event ClickedRightEvt.</summary>
 224    public void On_ClickedRightEvt(Efl.Ui.ClickableClickedRightEvt_Args e)
 225    {
 226       EventHandler<Efl.Ui.ClickableClickedRightEvt_Args> evt;
 227       lock (eventLock) {
 228       evt = (EventHandler<Efl.Ui.ClickableClickedRightEvt_Args>)eventHandlers[ClickedRightEvtKey];
 229       }
 230       evt?.Invoke(this, e);
 231    }
 232    Efl.EventCb evt_ClickedRightEvt_delegate;
 233    private void on_ClickedRightEvt_NativeCallback(System.IntPtr data, ref Efl.Event_StructInternal evt)
 234    {
 235       Efl.Ui.ClickableClickedRightEvt_Args args = new Efl.Ui.ClickableClickedRightEvt_Args();
 236       args.arg = new Efl.Object(evt.Info);
 237       try {
 238          On_ClickedRightEvt(args);
 239       } catch (Exception e) {
 240          Eina.Log.Error(e.ToString());
 241          Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 242       }
 243    }
 244
 245 private static object PressedEvtKey = new object();
 246    /// <summary>Called when the object is pressed</summary>
 247    public event EventHandler<Efl.Ui.ClickablePressedEvt_Args> PressedEvt
 248    {
 249       add {
 250          lock (eventLock) {
 251             string key = "_EFL_UI_EVENT_PRESSED";
 252             if (add_cpp_event_handler(efl.Libs.Efl, key, this.evt_PressedEvt_delegate)) {
 253                eventHandlers.AddHandler(PressedEvtKey , value);
 254             } else
 255                Eina.Log.Error($"Error adding proxy for event {key}");
 256          }
 257       }
 258       remove {
 259          lock (eventLock) {
 260             string key = "_EFL_UI_EVENT_PRESSED";
 261             if (remove_cpp_event_handler(key, this.evt_PressedEvt_delegate)) {
 262                eventHandlers.RemoveHandler(PressedEvtKey , value);
 263             } else
 264                Eina.Log.Error($"Error removing proxy for event {key}");
 265          }
 266       }
 267    }
 268    ///<summary>Method to raise event PressedEvt.</summary>
 269    public void On_PressedEvt(Efl.Ui.ClickablePressedEvt_Args e)
 270    {
 271       EventHandler<Efl.Ui.ClickablePressedEvt_Args> evt;
 272       lock (eventLock) {
 273       evt = (EventHandler<Efl.Ui.ClickablePressedEvt_Args>)eventHandlers[PressedEvtKey];
 274       }
 275       evt?.Invoke(this, e);
 276    }
 277    Efl.EventCb evt_PressedEvt_delegate;
 278    private void on_PressedEvt_NativeCallback(System.IntPtr data, ref Efl.Event_StructInternal evt)
 279    {
 280       Efl.Ui.ClickablePressedEvt_Args args = new Efl.Ui.ClickablePressedEvt_Args();
 281       args.arg = new Efl.Object(evt.Info);
 282       try {
 283          On_PressedEvt(args);
 284       } catch (Exception e) {
 285          Eina.Log.Error(e.ToString());
 286          Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 287       }
 288    }
 289
 290 private static object UnpressedEvtKey = new object();
 291    /// <summary>Called when the object is no longer pressed</summary>
 292    public event EventHandler<Efl.Ui.ClickableUnpressedEvt_Args> UnpressedEvt
 293    {
 294       add {
 295          lock (eventLock) {
 296             string key = "_EFL_UI_EVENT_UNPRESSED";
 297             if (add_cpp_event_handler(efl.Libs.Efl, key, this.evt_UnpressedEvt_delegate)) {
 298                eventHandlers.AddHandler(UnpressedEvtKey , value);
 299             } else
 300                Eina.Log.Error($"Error adding proxy for event {key}");
 301          }
 302       }
 303       remove {
 304          lock (eventLock) {
 305             string key = "_EFL_UI_EVENT_UNPRESSED";
 306             if (remove_cpp_event_handler(key, this.evt_UnpressedEvt_delegate)) {
 307                eventHandlers.RemoveHandler(UnpressedEvtKey , value);
 308             } else
 309                Eina.Log.Error($"Error removing proxy for event {key}");
 310          }
 311       }
 312    }
 313    ///<summary>Method to raise event UnpressedEvt.</summary>
 314    public void On_UnpressedEvt(Efl.Ui.ClickableUnpressedEvt_Args e)
 315    {
 316       EventHandler<Efl.Ui.ClickableUnpressedEvt_Args> evt;
 317       lock (eventLock) {
 318       evt = (EventHandler<Efl.Ui.ClickableUnpressedEvt_Args>)eventHandlers[UnpressedEvtKey];
 319       }
 320       evt?.Invoke(this, e);
 321    }
 322    Efl.EventCb evt_UnpressedEvt_delegate;
 323    private void on_UnpressedEvt_NativeCallback(System.IntPtr data, ref Efl.Event_StructInternal evt)
 324    {
 325       Efl.Ui.ClickableUnpressedEvt_Args args = new Efl.Ui.ClickableUnpressedEvt_Args();
 326       args.arg = new Efl.Object(evt.Info);
 327       try {
 328          On_UnpressedEvt(args);
 329       } catch (Exception e) {
 330          Eina.Log.Error(e.ToString());
 331          Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 332       }
 333    }
 334
 335 private static object LongpressedEvtKey = new object();
 336    /// <summary>Called when the object receives a long press</summary>
 337    public event EventHandler<Efl.Ui.ClickableLongpressedEvt_Args> LongpressedEvt
 338    {
 339       add {
 340          lock (eventLock) {
 341             string key = "_EFL_UI_EVENT_LONGPRESSED";
 342             if (add_cpp_event_handler(efl.Libs.Efl, key, this.evt_LongpressedEvt_delegate)) {
 343                eventHandlers.AddHandler(LongpressedEvtKey , value);
 344             } else
 345                Eina.Log.Error($"Error adding proxy for event {key}");
 346          }
 347       }
 348       remove {
 349          lock (eventLock) {
 350             string key = "_EFL_UI_EVENT_LONGPRESSED";
 351             if (remove_cpp_event_handler(key, this.evt_LongpressedEvt_delegate)) {
 352                eventHandlers.RemoveHandler(LongpressedEvtKey , value);
 353             } else
 354                Eina.Log.Error($"Error removing proxy for event {key}");
 355          }
 356       }
 357    }
 358    ///<summary>Method to raise event LongpressedEvt.</summary>
 359    public void On_LongpressedEvt(Efl.Ui.ClickableLongpressedEvt_Args e)
 360    {
 361       EventHandler<Efl.Ui.ClickableLongpressedEvt_Args> evt;
 362       lock (eventLock) {
 363       evt = (EventHandler<Efl.Ui.ClickableLongpressedEvt_Args>)eventHandlers[LongpressedEvtKey];
 364       }
 365       evt?.Invoke(this, e);
 366    }
 367    Efl.EventCb evt_LongpressedEvt_delegate;
 368    private void on_LongpressedEvt_NativeCallback(System.IntPtr data, ref Efl.Event_StructInternal evt)
 369    {
 370       Efl.Ui.ClickableLongpressedEvt_Args args = new Efl.Ui.ClickableLongpressedEvt_Args();
 371       args.arg = new Efl.Object(evt.Info);
 372       try {
 373          On_LongpressedEvt(args);
 374       } catch (Exception e) {
 375          Eina.Log.Error(e.ToString());
 376          Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 377       }
 378    }
 379
 380 private static object RepeatedEvtKey = new object();
 381    /// <summary>Called when the object receives repeated presses/clicks</summary>
 382    public event EventHandler RepeatedEvt
 383    {
 384       add {
 385          lock (eventLock) {
 386             string key = "_EFL_UI_EVENT_REPEATED";
 387             if (add_cpp_event_handler(efl.Libs.Efl, key, this.evt_RepeatedEvt_delegate)) {
 388                eventHandlers.AddHandler(RepeatedEvtKey , value);
 389             } else
 390                Eina.Log.Error($"Error adding proxy for event {key}");
 391          }
 392       }
 393       remove {
 394          lock (eventLock) {
 395             string key = "_EFL_UI_EVENT_REPEATED";
 396             if (remove_cpp_event_handler(key, this.evt_RepeatedEvt_delegate)) {
 397                eventHandlers.RemoveHandler(RepeatedEvtKey , value);
 398             } else
 399                Eina.Log.Error($"Error removing proxy for event {key}");
 400          }
 401       }
 402    }
 403    ///<summary>Method to raise event RepeatedEvt.</summary>
 404    public void On_RepeatedEvt(EventArgs e)
 405    {
 406       EventHandler evt;
 407       lock (eventLock) {
 408       evt = (EventHandler)eventHandlers[RepeatedEvtKey];
 409       }
 410       evt?.Invoke(this, e);
 411    }
 412    Efl.EventCb evt_RepeatedEvt_delegate;
 413    private void on_RepeatedEvt_NativeCallback(System.IntPtr data, ref Efl.Event_StructInternal evt)
 414    {
 415       EventArgs args = EventArgs.Empty;
 416       try {
 417          On_RepeatedEvt(args);
 418       } catch (Exception e) {
 419          Eina.Log.Error(e.ToString());
 420          Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 421       }
 422    }
 423
 424 private static object SelectedEvtKey = new object();
 425    /// <summary>Called when selected</summary>
 426    public event EventHandler SelectedEvt
 427    {
 428       add {
 429          lock (eventLock) {
 430             string key = "_EFL_UI_EVENT_SELECTED";
 431             if (add_cpp_event_handler(efl.Libs.Efl, key, this.evt_SelectedEvt_delegate)) {
 432                eventHandlers.AddHandler(SelectedEvtKey , value);
 433             } else
 434                Eina.Log.Error($"Error adding proxy for event {key}");
 435          }
 436       }
 437       remove {
 438          lock (eventLock) {
 439             string key = "_EFL_UI_EVENT_SELECTED";
 440             if (remove_cpp_event_handler(key, this.evt_SelectedEvt_delegate)) {
 441                eventHandlers.RemoveHandler(SelectedEvtKey , value);
 442             } else
 443                Eina.Log.Error($"Error removing proxy for event {key}");
 444          }
 445       }
 446    }
 447    ///<summary>Method to raise event SelectedEvt.</summary>
 448    public void On_SelectedEvt(EventArgs e)
 449    {
 450       EventHandler evt;
 451       lock (eventLock) {
 452       evt = (EventHandler)eventHandlers[SelectedEvtKey];
 453       }
 454       evt?.Invoke(this, e);
 455    }
 456    Efl.EventCb evt_SelectedEvt_delegate;
 457    private void on_SelectedEvt_NativeCallback(System.IntPtr data, ref Efl.Event_StructInternal evt)
 458    {
 459       EventArgs args = EventArgs.Empty;
 460       try {
 461          On_SelectedEvt(args);
 462       } catch (Exception e) {
 463          Eina.Log.Error(e.ToString());
 464          Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 465       }
 466    }
 467
 468 private static object UnselectedEvtKey = new object();
 469    /// <summary>Called when no longer selected</summary>
 470    public event EventHandler UnselectedEvt
 471    {
 472       add {
 473          lock (eventLock) {
 474             string key = "_EFL_UI_EVENT_UNSELECTED";
 475             if (add_cpp_event_handler(efl.Libs.Efl, key, this.evt_UnselectedEvt_delegate)) {
 476                eventHandlers.AddHandler(UnselectedEvtKey , value);
 477             } else
 478                Eina.Log.Error($"Error adding proxy for event {key}");
 479          }
 480       }
 481       remove {
 482          lock (eventLock) {
 483             string key = "_EFL_UI_EVENT_UNSELECTED";
 484             if (remove_cpp_event_handler(key, this.evt_UnselectedEvt_delegate)) {
 485                eventHandlers.RemoveHandler(UnselectedEvtKey , value);
 486             } else
 487                Eina.Log.Error($"Error removing proxy for event {key}");
 488          }
 489       }
 490    }
 491    ///<summary>Method to raise event UnselectedEvt.</summary>
 492    public void On_UnselectedEvt(EventArgs e)
 493    {
 494       EventHandler evt;
 495       lock (eventLock) {
 496       evt = (EventHandler)eventHandlers[UnselectedEvtKey];
 497       }
 498       evt?.Invoke(this, e);
 499    }
 500    Efl.EventCb evt_UnselectedEvt_delegate;
 501    private void on_UnselectedEvt_NativeCallback(System.IntPtr data, ref Efl.Event_StructInternal evt)
 502    {
 503       EventArgs args = EventArgs.Empty;
 504       try {
 505          On_UnselectedEvt(args);
 506       } catch (Exception e) {
 507          Eina.Log.Error(e.ToString());
 508          Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 509       }
 510    }
 511
 512 private static object SelectionPasteEvtKey = new object();
 513    /// <summary>Called when selection is pasted</summary>
 514    public event EventHandler SelectionPasteEvt
 515    {
 516       add {
 517          lock (eventLock) {
 518             string key = "_EFL_UI_EVENT_SELECTION_PASTE";
 519             if (add_cpp_event_handler(efl.Libs.Efl, key, this.evt_SelectionPasteEvt_delegate)) {
 520                eventHandlers.AddHandler(SelectionPasteEvtKey , value);
 521             } else
 522                Eina.Log.Error($"Error adding proxy for event {key}");
 523          }
 524       }
 525       remove {
 526          lock (eventLock) {
 527             string key = "_EFL_UI_EVENT_SELECTION_PASTE";
 528             if (remove_cpp_event_handler(key, this.evt_SelectionPasteEvt_delegate)) {
 529                eventHandlers.RemoveHandler(SelectionPasteEvtKey , value);
 530             } else
 531                Eina.Log.Error($"Error removing proxy for event {key}");
 532          }
 533       }
 534    }
 535    ///<summary>Method to raise event SelectionPasteEvt.</summary>
 536    public void On_SelectionPasteEvt(EventArgs e)
 537    {
 538       EventHandler evt;
 539       lock (eventLock) {
 540       evt = (EventHandler)eventHandlers[SelectionPasteEvtKey];
 541       }
 542       evt?.Invoke(this, e);
 543    }
 544    Efl.EventCb evt_SelectionPasteEvt_delegate;
 545    private void on_SelectionPasteEvt_NativeCallback(System.IntPtr data, ref Efl.Event_StructInternal evt)
 546    {
 547       EventArgs args = EventArgs.Empty;
 548       try {
 549          On_SelectionPasteEvt(args);
 550       } catch (Exception e) {
 551          Eina.Log.Error(e.ToString());
 552          Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 553       }
 554    }
 555
 556 private static object SelectionCopyEvtKey = new object();
 557    /// <summary>Called when selection is copied</summary>
 558    public event EventHandler SelectionCopyEvt
 559    {
 560       add {
 561          lock (eventLock) {
 562             string key = "_EFL_UI_EVENT_SELECTION_COPY";
 563             if (add_cpp_event_handler(efl.Libs.Efl, key, this.evt_SelectionCopyEvt_delegate)) {
 564                eventHandlers.AddHandler(SelectionCopyEvtKey , value);
 565             } else
 566                Eina.Log.Error($"Error adding proxy for event {key}");
 567          }
 568       }
 569       remove {
 570          lock (eventLock) {
 571             string key = "_EFL_UI_EVENT_SELECTION_COPY";
 572             if (remove_cpp_event_handler(key, this.evt_SelectionCopyEvt_delegate)) {
 573                eventHandlers.RemoveHandler(SelectionCopyEvtKey , value);
 574             } else
 575                Eina.Log.Error($"Error removing proxy for event {key}");
 576          }
 577       }
 578    }
 579    ///<summary>Method to raise event SelectionCopyEvt.</summary>
 580    public void On_SelectionCopyEvt(EventArgs e)
 581    {
 582       EventHandler evt;
 583       lock (eventLock) {
 584       evt = (EventHandler)eventHandlers[SelectionCopyEvtKey];
 585       }
 586       evt?.Invoke(this, e);
 587    }
 588    Efl.EventCb evt_SelectionCopyEvt_delegate;
 589    private void on_SelectionCopyEvt_NativeCallback(System.IntPtr data, ref Efl.Event_StructInternal evt)
 590    {
 591       EventArgs args = EventArgs.Empty;
 592       try {
 593          On_SelectionCopyEvt(args);
 594       } catch (Exception e) {
 595          Eina.Log.Error(e.ToString());
 596          Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 597       }
 598    }
 599
 600 private static object SelectionCutEvtKey = new object();
 601    /// <summary>Called when selection is cut</summary>
 602    public event EventHandler SelectionCutEvt
 603    {
 604       add {
 605          lock (eventLock) {
 606             string key = "_EFL_UI_EVENT_SELECTION_CUT";
 607             if (add_cpp_event_handler(efl.Libs.Efl, key, this.evt_SelectionCutEvt_delegate)) {
 608                eventHandlers.AddHandler(SelectionCutEvtKey , value);
 609             } else
 610                Eina.Log.Error($"Error adding proxy for event {key}");
 611          }
 612       }
 613       remove {
 614          lock (eventLock) {
 615             string key = "_EFL_UI_EVENT_SELECTION_CUT";
 616             if (remove_cpp_event_handler(key, this.evt_SelectionCutEvt_delegate)) {
 617                eventHandlers.RemoveHandler(SelectionCutEvtKey , value);
 618             } else
 619                Eina.Log.Error($"Error removing proxy for event {key}");
 620          }
 621       }
 622    }
 623    ///<summary>Method to raise event SelectionCutEvt.</summary>
 624    public void On_SelectionCutEvt(EventArgs e)
 625    {
 626       EventHandler evt;
 627       lock (eventLock) {
 628       evt = (EventHandler)eventHandlers[SelectionCutEvtKey];
 629       }
 630       evt?.Invoke(this, e);
 631    }
 632    Efl.EventCb evt_SelectionCutEvt_delegate;
 633    private void on_SelectionCutEvt_NativeCallback(System.IntPtr data, ref Efl.Event_StructInternal evt)
 634    {
 635       EventArgs args = EventArgs.Empty;
 636       try {
 637          On_SelectionCutEvt(args);
 638       } catch (Exception e) {
 639          Eina.Log.Error(e.ToString());
 640          Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 641       }
 642    }
 643
 644 private static object SelectionStartEvtKey = new object();
 645    /// <summary>Called at selection start</summary>
 646    public event EventHandler SelectionStartEvt
 647    {
 648       add {
 649          lock (eventLock) {
 650             string key = "_EFL_UI_EVENT_SELECTION_START";
 651             if (add_cpp_event_handler(efl.Libs.Efl, key, this.evt_SelectionStartEvt_delegate)) {
 652                eventHandlers.AddHandler(SelectionStartEvtKey , value);
 653             } else
 654                Eina.Log.Error($"Error adding proxy for event {key}");
 655          }
 656       }
 657       remove {
 658          lock (eventLock) {
 659             string key = "_EFL_UI_EVENT_SELECTION_START";
 660             if (remove_cpp_event_handler(key, this.evt_SelectionStartEvt_delegate)) {
 661                eventHandlers.RemoveHandler(SelectionStartEvtKey , value);
 662             } else
 663                Eina.Log.Error($"Error removing proxy for event {key}");
 664          }
 665       }
 666    }
 667    ///<summary>Method to raise event SelectionStartEvt.</summary>
 668    public void On_SelectionStartEvt(EventArgs e)
 669    {
 670       EventHandler evt;
 671       lock (eventLock) {
 672       evt = (EventHandler)eventHandlers[SelectionStartEvtKey];
 673       }
 674       evt?.Invoke(this, e);
 675    }
 676    Efl.EventCb evt_SelectionStartEvt_delegate;
 677    private void on_SelectionStartEvt_NativeCallback(System.IntPtr data, ref Efl.Event_StructInternal evt)
 678    {
 679       EventArgs args = EventArgs.Empty;
 680       try {
 681          On_SelectionStartEvt(args);
 682       } catch (Exception e) {
 683          Eina.Log.Error(e.ToString());
 684          Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 685       }
 686    }
 687
 688 private static object Efl_Ui_Selectable_SelectionChangedEvtKey = new object();
 689    /// <summary>Called when selection is changed</summary>
 690     event EventHandler Efl.Ui.Selectable.SelectionChangedEvt
 691    {
 692       add {
 693          lock (eventLock) {
 694             string key = "_EFL_UI_EVENT_SELECTION_CHANGED";
 695             if (add_cpp_event_handler(efl.Libs.Efl, key, this.evt_Efl_Ui_Selectable_SelectionChangedEvt_delegate)) {
 696                eventHandlers.AddHandler(Efl_Ui_Selectable_SelectionChangedEvtKey , value);
 697             } else
 698                Eina.Log.Error($"Error adding proxy for event {key}");
 699          }
 700       }
 701       remove {
 702          lock (eventLock) {
 703             string key = "_EFL_UI_EVENT_SELECTION_CHANGED";
 704             if (remove_cpp_event_handler(key, this.evt_Efl_Ui_Selectable_SelectionChangedEvt_delegate)) {
 705                eventHandlers.RemoveHandler(Efl_Ui_Selectable_SelectionChangedEvtKey , value);
 706             } else
 707                Eina.Log.Error($"Error removing proxy for event {key}");
 708          }
 709       }
 710    }
 711    ///<summary>Method to raise event Efl_Ui_Selectable_SelectionChangedEvt.</summary>
 712    public void On_Efl_Ui_Selectable_SelectionChangedEvt(EventArgs e)
 713    {
 714       EventHandler evt;
 715       lock (eventLock) {
 716       evt = (EventHandler)eventHandlers[Efl_Ui_Selectable_SelectionChangedEvtKey];
 717       }
 718       evt?.Invoke(this, e);
 719    }
 720    Efl.EventCb evt_Efl_Ui_Selectable_SelectionChangedEvt_delegate;
 721    private void on_Efl_Ui_Selectable_SelectionChangedEvt_NativeCallback(System.IntPtr data, ref Efl.Event_StructInternal evt)
 722    {
 723       EventArgs args = EventArgs.Empty;
 724       try {
 725          On_Efl_Ui_Selectable_SelectionChangedEvt(args);
 726       } catch (Exception e) {
 727          Eina.Log.Error(e.ToString());
 728          Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 729       }
 730    }
 731
 732 private static object SelectionClearedEvtKey = new object();
 733    /// <summary>Called when selection is cleared</summary>
 734    public event EventHandler SelectionClearedEvt
 735    {
 736       add {
 737          lock (eventLock) {
 738             string key = "_EFL_UI_EVENT_SELECTION_CLEARED";
 739             if (add_cpp_event_handler(efl.Libs.Efl, key, this.evt_SelectionClearedEvt_delegate)) {
 740                eventHandlers.AddHandler(SelectionClearedEvtKey , value);
 741             } else
 742                Eina.Log.Error($"Error adding proxy for event {key}");
 743          }
 744       }
 745       remove {
 746          lock (eventLock) {
 747             string key = "_EFL_UI_EVENT_SELECTION_CLEARED";
 748             if (remove_cpp_event_handler(key, this.evt_SelectionClearedEvt_delegate)) {
 749                eventHandlers.RemoveHandler(SelectionClearedEvtKey , value);
 750             } else
 751                Eina.Log.Error($"Error removing proxy for event {key}");
 752          }
 753       }
 754    }
 755    ///<summary>Method to raise event SelectionClearedEvt.</summary>
 756    public void On_SelectionClearedEvt(EventArgs e)
 757    {
 758       EventHandler evt;
 759       lock (eventLock) {
 760       evt = (EventHandler)eventHandlers[SelectionClearedEvtKey];
 761       }
 762       evt?.Invoke(this, e);
 763    }
 764    Efl.EventCb evt_SelectionClearedEvt_delegate;
 765    private void on_SelectionClearedEvt_NativeCallback(System.IntPtr data, ref Efl.Event_StructInternal evt)
 766    {
 767       EventArgs args = EventArgs.Empty;
 768       try {
 769          On_SelectionClearedEvt(args);
 770       } catch (Exception e) {
 771          Eina.Log.Error(e.ToString());
 772          Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 773       }
 774    }
 775
 776    protected override void register_event_proxies()
 777    {
 778       base.register_event_proxies();
 779       evt_ClickedEvt_delegate = new Efl.EventCb(on_ClickedEvt_NativeCallback);
 780       evt_ClickedDoubleEvt_delegate = new Efl.EventCb(on_ClickedDoubleEvt_NativeCallback);
 781       evt_ClickedTripleEvt_delegate = new Efl.EventCb(on_ClickedTripleEvt_NativeCallback);
 782       evt_ClickedRightEvt_delegate = new Efl.EventCb(on_ClickedRightEvt_NativeCallback);
 783       evt_PressedEvt_delegate = new Efl.EventCb(on_PressedEvt_NativeCallback);
 784       evt_UnpressedEvt_delegate = new Efl.EventCb(on_UnpressedEvt_NativeCallback);
 785       evt_LongpressedEvt_delegate = new Efl.EventCb(on_LongpressedEvt_NativeCallback);
 786       evt_RepeatedEvt_delegate = new Efl.EventCb(on_RepeatedEvt_NativeCallback);
 787       evt_SelectedEvt_delegate = new Efl.EventCb(on_SelectedEvt_NativeCallback);
 788       evt_UnselectedEvt_delegate = new Efl.EventCb(on_UnselectedEvt_NativeCallback);
 789       evt_SelectionPasteEvt_delegate = new Efl.EventCb(on_SelectionPasteEvt_NativeCallback);
 790       evt_SelectionCopyEvt_delegate = new Efl.EventCb(on_SelectionCopyEvt_NativeCallback);
 791       evt_SelectionCutEvt_delegate = new Efl.EventCb(on_SelectionCutEvt_NativeCallback);
 792       evt_SelectionStartEvt_delegate = new Efl.EventCb(on_SelectionStartEvt_NativeCallback);
 793       evt_Efl_Ui_Selectable_SelectionChangedEvt_delegate = new Efl.EventCb(on_Efl_Ui_Selectable_SelectionChangedEvt_NativeCallback);
 794       evt_SelectionClearedEvt_delegate = new Efl.EventCb(on_SelectionClearedEvt_NativeCallback);
 795    }
 796    /// <summary>index number of item from their parent object.</summary>
 797    /// <returns></returns>
 798    virtual public  int GetIndex() {
 799        var _ret_var = Efl.Ui.ItemNativeInherit.efl_ui_item_index_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 800       Eina.Error.RaiseIfUnhandledException();
 801       return _ret_var;
 802  }
 803    /// <summary>Select property for item object. Item can be selected by user mouse/key input also</summary>
 804    /// <returns></returns>
 805    virtual public bool GetSelected() {
 806        var _ret_var = Efl.Ui.ItemNativeInherit.efl_ui_item_selected_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 807       Eina.Error.RaiseIfUnhandledException();
 808       return _ret_var;
 809  }
 810    /// <summary>Select property for item object. Item can be selected by user mouse/key input also</summary>
 811    /// <param name="select"></param>
 812    /// <returns></returns>
 813    virtual public  void SetSelected( bool select) {
 814                          Efl.Ui.ItemNativeInherit.efl_ui_item_selected_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), select);
 815       Eina.Error.RaiseIfUnhandledException();
 816                    }
 817    /// <summary>index number of item from their parent object.</summary>
 818 /// <value></value>
 819    public  int Index {
 820       get { return GetIndex(); }
 821    }
 822    /// <summary>Select property for item object. Item can be selected by user mouse/key input also</summary>
 823 /// <value></value>
 824    public bool Selected {
 825       get { return GetSelected(); }
 826       set { SetSelected( value); }
 827    }
 828    private static new  IntPtr GetEflClassStatic()
 829    {
 830       return Efl.Ui.Item.efl_ui_item_class_get();
 831    }
 832 }
 833 public class ItemNativeInherit : Efl.Ui.LayoutBaseNativeInherit{
 834    public new  static Efl.Eo.NativeModule _Module = new Efl.Eo.NativeModule(efl.Libs.Elementary);
 835    public override System.Collections.Generic.List<Efl_Op_Description> GetEoOps(System.Type type)
 836    {
 837       var descs = new System.Collections.Generic.List<Efl_Op_Description>();
 838       if (efl_ui_item_index_get_static_delegate == null)
 839       efl_ui_item_index_get_static_delegate = new efl_ui_item_index_get_delegate(index_get);
 840       descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_ui_item_index_get"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_item_index_get_static_delegate)});
 841       if (efl_ui_item_selected_get_static_delegate == null)
 842       efl_ui_item_selected_get_static_delegate = new efl_ui_item_selected_get_delegate(selected_get);
 843       descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_ui_item_selected_get"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_item_selected_get_static_delegate)});
 844       if (efl_ui_item_selected_set_static_delegate == null)
 845       efl_ui_item_selected_set_static_delegate = new efl_ui_item_selected_set_delegate(selected_set);
 846       descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_ui_item_selected_set"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_item_selected_set_static_delegate)});
 847       descs.AddRange(base.GetEoOps(type));
 848       return descs;
 849    }
 850    public override IntPtr GetEflClass()
 851    {
 852       return Efl.Ui.Item.efl_ui_item_class_get();
 853    }
 854    public static new  IntPtr GetEflClassStatic()
 855    {
 856       return Efl.Ui.Item.efl_ui_item_class_get();
 857    }
 858
 859
 860     private delegate  int efl_ui_item_index_get_delegate(System.IntPtr obj, System.IntPtr pd);
 861
 862
 863     public delegate  int efl_ui_item_index_get_api_delegate(System.IntPtr obj);
 864     public static Efl.Eo.FunctionWrapper<efl_ui_item_index_get_api_delegate> efl_ui_item_index_get_ptr = new Efl.Eo.FunctionWrapper<efl_ui_item_index_get_api_delegate>(_Module, "efl_ui_item_index_get");
 865     private static  int index_get(System.IntPtr obj, System.IntPtr pd)
 866    {
 867       Eina.Log.Debug("function efl_ui_item_index_get was called");
 868       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
 869       if(wrapper != null) {
 870                    int _ret_var = default( int);
 871          try {
 872             _ret_var = ((Item)wrapper).GetIndex();
 873          } catch (Exception e) {
 874             Eina.Log.Warning($"Callback error: {e.ToString()}");
 875             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 876          }
 877       return _ret_var;
 878       } else {
 879          return efl_ui_item_index_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
 880       }
 881    }
 882    private static efl_ui_item_index_get_delegate efl_ui_item_index_get_static_delegate;
 883
 884
 885     [return: MarshalAs(UnmanagedType.U1)] private delegate bool efl_ui_item_selected_get_delegate(System.IntPtr obj, System.IntPtr pd);
 886
 887
 888     [return: MarshalAs(UnmanagedType.U1)] public delegate bool efl_ui_item_selected_get_api_delegate(System.IntPtr obj);
 889     public static Efl.Eo.FunctionWrapper<efl_ui_item_selected_get_api_delegate> efl_ui_item_selected_get_ptr = new Efl.Eo.FunctionWrapper<efl_ui_item_selected_get_api_delegate>(_Module, "efl_ui_item_selected_get");
 890     private static bool selected_get(System.IntPtr obj, System.IntPtr pd)
 891    {
 892       Eina.Log.Debug("function efl_ui_item_selected_get was called");
 893       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
 894       if(wrapper != null) {
 895                   bool _ret_var = default(bool);
 896          try {
 897             _ret_var = ((Item)wrapper).GetSelected();
 898          } catch (Exception e) {
 899             Eina.Log.Warning($"Callback error: {e.ToString()}");
 900             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 901          }
 902       return _ret_var;
 903       } else {
 904          return efl_ui_item_selected_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
 905       }
 906    }
 907    private static efl_ui_item_selected_get_delegate efl_ui_item_selected_get_static_delegate;
 908
 909
 910     private delegate  void efl_ui_item_selected_set_delegate(System.IntPtr obj, System.IntPtr pd,  [MarshalAs(UnmanagedType.U1)]  bool select);
 911
 912
 913     public delegate  void efl_ui_item_selected_set_api_delegate(System.IntPtr obj,  [MarshalAs(UnmanagedType.U1)]  bool select);
 914     public static Efl.Eo.FunctionWrapper<efl_ui_item_selected_set_api_delegate> efl_ui_item_selected_set_ptr = new Efl.Eo.FunctionWrapper<efl_ui_item_selected_set_api_delegate>(_Module, "efl_ui_item_selected_set");
 915     private static  void selected_set(System.IntPtr obj, System.IntPtr pd,  bool select)
 916    {
 917       Eina.Log.Debug("function efl_ui_item_selected_set was called");
 918       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
 919       if(wrapper != null) {
 920
 921          try {
 922             ((Item)wrapper).SetSelected( select);
 923          } catch (Exception e) {
 924             Eina.Log.Warning($"Callback error: {e.ToString()}");
 925             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 926          }
 927                         } else {
 928          efl_ui_item_selected_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  select);
 929       }
 930    }
 931    private static efl_ui_item_selected_set_delegate efl_ui_item_selected_set_static_delegate;
 932 }
 933 } }