internals/src/EflSharp/EflSharp/efl_ui_scrollable.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>Efl UI scrollable interface</summary>
   9 [ScrollableNativeInherit]
  10 public interface Scrollable :
  11    Efl.Eo.IWrapper, IDisposable
  12 {
  13    /// <summary>Called when scroll operation starts</summary>
  14    event EventHandler ScrollStartEvt;
  15    /// <summary>Called when scrolling</summary>
  16    event EventHandler ScrollEvt;
  17    /// <summary>Called when scroll operation stops</summary>
  18    event EventHandler ScrollStopEvt;
  19    /// <summary>Called when scrolling upwards</summary>
  20    event EventHandler ScrollUpEvt;
  21    /// <summary>Called when scrolling downwards</summary>
  22    event EventHandler ScrollDownEvt;
  23    /// <summary>Called when scrolling left</summary>
  24    event EventHandler ScrollLeftEvt;
  25    /// <summary>Called when scrolling right</summary>
  26    event EventHandler ScrollRightEvt;
  27    /// <summary>Called when hitting the top edge</summary>
  28    event EventHandler EdgeUpEvt;
  29    /// <summary>Called when hitting the bottom edge</summary>
  30    event EventHandler EdgeDownEvt;
  31    /// <summary>Called when hitting the left edge</summary>
  32    event EventHandler EdgeLeftEvt;
  33    /// <summary>Called when hitting the right edge</summary>
  34    event EventHandler EdgeRightEvt;
  35    /// <summary>Called when scroll animation starts</summary>
  36    event EventHandler ScrollAnimStartEvt;
  37    /// <summary>Called when scroll animation stopps</summary>
  38    event EventHandler ScrollAnimStopEvt;
  39    /// <summary>Called when scroll drag starts</summary>
  40    event EventHandler ScrollDragStartEvt;
  41    /// <summary>Called when scroll drag stops</summary>
  42    event EventHandler ScrollDragStopEvt;
  43 }
  44 /// <summary>Efl UI scrollable interface</summary>
  45 sealed public class ScrollableConcrete :
  46
  47 Scrollable
  48
  49 {
  50    ///<summary>Pointer to the native class description.</summary>
  51    public System.IntPtr NativeClass {
  52       get {
  53          if (((object)this).GetType() == typeof (ScrollableConcrete))
  54             return Efl.Ui.ScrollableNativeInherit.GetEflClassStatic();
  55          else
  56             return Efl.Eo.ClassRegister.klassFromType[((object)this).GetType()];
  57       }
  58    }
  59    private EventHandlerList eventHandlers = new EventHandlerList();
  60    private  System.IntPtr handle;
  61    ///<summary>Pointer to the native instance.</summary>
  62    public System.IntPtr NativeHandle {
  63       get { return handle; }
  64    }
  65    [System.Runtime.InteropServices.DllImport(efl.Libs.Efl)] internal static extern System.IntPtr
  66       efl_ui_scrollable_interface_get();
  67    ///<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>
  68    public ScrollableConcrete(System.IntPtr raw)
  69    {
  70       handle = raw;
  71       register_event_proxies();
  72    }
  73    ///<summary>Destructor.</summary>
  74    ~ScrollableConcrete()
  75    {
  76       Dispose(false);
  77    }
  78    ///<summary>Releases the underlying native instance.</summary>
  79    void Dispose(bool disposing)
  80    {
  81       if (handle != System.IntPtr.Zero) {
  82          Efl.Eo.Globals.efl_unref(handle);
  83          handle = System.IntPtr.Zero;
  84       }
  85    }
  86    ///<summary>Releases the underlying native instance.</summary>
  87    public void Dispose()
  88    {
  89       Dispose(true);
  90       GC.SuppressFinalize(this);
  91    }
  92    ///<summary>Casts obj into an instance of this type.</summary>
  93    public static ScrollableConcrete static_cast(Efl.Object obj)
  94    {
  95       if (obj == null)
  96          throw new System.ArgumentNullException("obj");
  97       return new ScrollableConcrete(obj.NativeHandle);
  98    }
  99    ///<summary>Verifies if the given object is equal to this one.</summary>
 100    public override bool Equals(object obj)
 101    {
 102       var other = obj as Efl.Object;
 103       if (other == null)
 104          return false;
 105       return this.NativeHandle == other.NativeHandle;
 106    }
 107    ///<summary>Gets the hash code for this object based on the native pointer it points to.</summary>
 108    public override int GetHashCode()
 109    {
 110       return this.NativeHandle.ToInt32();
 111    }
 112    ///<summary>Turns the native pointer into a string representation.</summary>
 113    public override String ToString()
 114    {
 115       return $"{this.GetType().Name}@[{this.NativeHandle.ToInt32():x}]";
 116    }
 117    private readonly object eventLock = new object();
 118    private Dictionary<string, int> event_cb_count = new Dictionary<string, int>();
 119    private bool add_cpp_event_handler(string lib, string key, Efl.EventCb evt_delegate) {
 120       int event_count = 0;
 121       if (!event_cb_count.TryGetValue(key, out event_count))
 122          event_cb_count[key] = event_count;
 123       if (event_count == 0) {
 124          IntPtr desc = Efl.EventDescription.GetNative(lib, key);
 125          if (desc == IntPtr.Zero) {
 126             Eina.Log.Error($"Failed to get native event {key}");
 127             return false;
 128          }
 129           bool result = Efl.Eo.Globals.efl_event_callback_priority_add(handle, desc, 0, evt_delegate, System.IntPtr.Zero);
 130          if (!result) {
 131             Eina.Log.Error($"Failed to add event proxy for event {key}");
 132             return false;
 133          }
 134          Eina.Error.RaiseIfUnhandledException();
 135       }
 136       event_cb_count[key]++;
 137       return true;
 138    }
 139    private bool remove_cpp_event_handler(string key, Efl.EventCb evt_delegate) {
 140       int event_count = 0;
 141       if (!event_cb_count.TryGetValue(key, out event_count))
 142          event_cb_count[key] = event_count;
 143       if (event_count == 1) {
 144          IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
 145          if (desc == IntPtr.Zero) {
 146             Eina.Log.Error($"Failed to get native event {key}");
 147             return false;
 148          }
 149          bool result = Efl.Eo.Globals.efl_event_callback_del(handle, desc, evt_delegate, System.IntPtr.Zero);
 150          if (!result) {
 151             Eina.Log.Error($"Failed to remove event proxy for event {key}");
 152             return false;
 153          }
 154          Eina.Error.RaiseIfUnhandledException();
 155       } else if (event_count == 0) {
 156          Eina.Log.Error($"Trying to remove proxy for event {key} when there is nothing registered.");
 157          return false;
 158       }
 159       event_cb_count[key]--;
 160       return true;
 161    }
 162 private static object ScrollStartEvtKey = new object();
 163    /// <summary>Called when scroll operation starts</summary>
 164    public event EventHandler ScrollStartEvt
 165    {
 166       add {
 167          lock (eventLock) {
 168             string key = "_EFL_UI_EVENT_SCROLL_START";
 169             if (add_cpp_event_handler(efl.Libs.Efl, key, this.evt_ScrollStartEvt_delegate)) {
 170                eventHandlers.AddHandler(ScrollStartEvtKey , value);
 171             } else
 172                Eina.Log.Error($"Error adding proxy for event {key}");
 173          }
 174       }
 175       remove {
 176          lock (eventLock) {
 177             string key = "_EFL_UI_EVENT_SCROLL_START";
 178             if (remove_cpp_event_handler(key, this.evt_ScrollStartEvt_delegate)) {
 179                eventHandlers.RemoveHandler(ScrollStartEvtKey , value);
 180             } else
 181                Eina.Log.Error($"Error removing proxy for event {key}");
 182          }
 183       }
 184    }
 185    ///<summary>Method to raise event ScrollStartEvt.</summary>
 186    public void On_ScrollStartEvt(EventArgs e)
 187    {
 188       EventHandler evt;
 189       lock (eventLock) {
 190       evt = (EventHandler)eventHandlers[ScrollStartEvtKey];
 191       }
 192       evt?.Invoke(this, e);
 193    }
 194    Efl.EventCb evt_ScrollStartEvt_delegate;
 195    private void on_ScrollStartEvt_NativeCallback(System.IntPtr data, ref Efl.Event_StructInternal evt)
 196    {
 197       EventArgs args = EventArgs.Empty;
 198       try {
 199          On_ScrollStartEvt(args);
 200       } catch (Exception e) {
 201          Eina.Log.Error(e.ToString());
 202          Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 203       }
 204    }
 205
 206 private static object ScrollEvtKey = new object();
 207    /// <summary>Called when scrolling</summary>
 208    public event EventHandler ScrollEvt
 209    {
 210       add {
 211          lock (eventLock) {
 212             string key = "_EFL_UI_EVENT_SCROLL";
 213             if (add_cpp_event_handler(efl.Libs.Efl, key, this.evt_ScrollEvt_delegate)) {
 214                eventHandlers.AddHandler(ScrollEvtKey , value);
 215             } else
 216                Eina.Log.Error($"Error adding proxy for event {key}");
 217          }
 218       }
 219       remove {
 220          lock (eventLock) {
 221             string key = "_EFL_UI_EVENT_SCROLL";
 222             if (remove_cpp_event_handler(key, this.evt_ScrollEvt_delegate)) {
 223                eventHandlers.RemoveHandler(ScrollEvtKey , value);
 224             } else
 225                Eina.Log.Error($"Error removing proxy for event {key}");
 226          }
 227       }
 228    }
 229    ///<summary>Method to raise event ScrollEvt.</summary>
 230    public void On_ScrollEvt(EventArgs e)
 231    {
 232       EventHandler evt;
 233       lock (eventLock) {
 234       evt = (EventHandler)eventHandlers[ScrollEvtKey];
 235       }
 236       evt?.Invoke(this, e);
 237    }
 238    Efl.EventCb evt_ScrollEvt_delegate;
 239    private void on_ScrollEvt_NativeCallback(System.IntPtr data, ref Efl.Event_StructInternal evt)
 240    {
 241       EventArgs args = EventArgs.Empty;
 242       try {
 243          On_ScrollEvt(args);
 244       } catch (Exception e) {
 245          Eina.Log.Error(e.ToString());
 246          Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 247       }
 248    }
 249
 250 private static object ScrollStopEvtKey = new object();
 251    /// <summary>Called when scroll operation stops</summary>
 252    public event EventHandler ScrollStopEvt
 253    {
 254       add {
 255          lock (eventLock) {
 256             string key = "_EFL_UI_EVENT_SCROLL_STOP";
 257             if (add_cpp_event_handler(efl.Libs.Efl, key, this.evt_ScrollStopEvt_delegate)) {
 258                eventHandlers.AddHandler(ScrollStopEvtKey , value);
 259             } else
 260                Eina.Log.Error($"Error adding proxy for event {key}");
 261          }
 262       }
 263       remove {
 264          lock (eventLock) {
 265             string key = "_EFL_UI_EVENT_SCROLL_STOP";
 266             if (remove_cpp_event_handler(key, this.evt_ScrollStopEvt_delegate)) {
 267                eventHandlers.RemoveHandler(ScrollStopEvtKey , value);
 268             } else
 269                Eina.Log.Error($"Error removing proxy for event {key}");
 270          }
 271       }
 272    }
 273    ///<summary>Method to raise event ScrollStopEvt.</summary>
 274    public void On_ScrollStopEvt(EventArgs e)
 275    {
 276       EventHandler evt;
 277       lock (eventLock) {
 278       evt = (EventHandler)eventHandlers[ScrollStopEvtKey];
 279       }
 280       evt?.Invoke(this, e);
 281    }
 282    Efl.EventCb evt_ScrollStopEvt_delegate;
 283    private void on_ScrollStopEvt_NativeCallback(System.IntPtr data, ref Efl.Event_StructInternal evt)
 284    {
 285       EventArgs args = EventArgs.Empty;
 286       try {
 287          On_ScrollStopEvt(args);
 288       } catch (Exception e) {
 289          Eina.Log.Error(e.ToString());
 290          Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 291       }
 292    }
 293
 294 private static object ScrollUpEvtKey = new object();
 295    /// <summary>Called when scrolling upwards</summary>
 296    public event EventHandler ScrollUpEvt
 297    {
 298       add {
 299          lock (eventLock) {
 300             string key = "_EFL_UI_EVENT_SCROLL_UP";
 301             if (add_cpp_event_handler(efl.Libs.Efl, key, this.evt_ScrollUpEvt_delegate)) {
 302                eventHandlers.AddHandler(ScrollUpEvtKey , value);
 303             } else
 304                Eina.Log.Error($"Error adding proxy for event {key}");
 305          }
 306       }
 307       remove {
 308          lock (eventLock) {
 309             string key = "_EFL_UI_EVENT_SCROLL_UP";
 310             if (remove_cpp_event_handler(key, this.evt_ScrollUpEvt_delegate)) {
 311                eventHandlers.RemoveHandler(ScrollUpEvtKey , value);
 312             } else
 313                Eina.Log.Error($"Error removing proxy for event {key}");
 314          }
 315       }
 316    }
 317    ///<summary>Method to raise event ScrollUpEvt.</summary>
 318    public void On_ScrollUpEvt(EventArgs e)
 319    {
 320       EventHandler evt;
 321       lock (eventLock) {
 322       evt = (EventHandler)eventHandlers[ScrollUpEvtKey];
 323       }
 324       evt?.Invoke(this, e);
 325    }
 326    Efl.EventCb evt_ScrollUpEvt_delegate;
 327    private void on_ScrollUpEvt_NativeCallback(System.IntPtr data, ref Efl.Event_StructInternal evt)
 328    {
 329       EventArgs args = EventArgs.Empty;
 330       try {
 331          On_ScrollUpEvt(args);
 332       } catch (Exception e) {
 333          Eina.Log.Error(e.ToString());
 334          Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 335       }
 336    }
 337
 338 private static object ScrollDownEvtKey = new object();
 339    /// <summary>Called when scrolling downwards</summary>
 340    public event EventHandler ScrollDownEvt
 341    {
 342       add {
 343          lock (eventLock) {
 344             string key = "_EFL_UI_EVENT_SCROLL_DOWN";
 345             if (add_cpp_event_handler(efl.Libs.Efl, key, this.evt_ScrollDownEvt_delegate)) {
 346                eventHandlers.AddHandler(ScrollDownEvtKey , value);
 347             } else
 348                Eina.Log.Error($"Error adding proxy for event {key}");
 349          }
 350       }
 351       remove {
 352          lock (eventLock) {
 353             string key = "_EFL_UI_EVENT_SCROLL_DOWN";
 354             if (remove_cpp_event_handler(key, this.evt_ScrollDownEvt_delegate)) {
 355                eventHandlers.RemoveHandler(ScrollDownEvtKey , value);
 356             } else
 357                Eina.Log.Error($"Error removing proxy for event {key}");
 358          }
 359       }
 360    }
 361    ///<summary>Method to raise event ScrollDownEvt.</summary>
 362    public void On_ScrollDownEvt(EventArgs e)
 363    {
 364       EventHandler evt;
 365       lock (eventLock) {
 366       evt = (EventHandler)eventHandlers[ScrollDownEvtKey];
 367       }
 368       evt?.Invoke(this, e);
 369    }
 370    Efl.EventCb evt_ScrollDownEvt_delegate;
 371    private void on_ScrollDownEvt_NativeCallback(System.IntPtr data, ref Efl.Event_StructInternal evt)
 372    {
 373       EventArgs args = EventArgs.Empty;
 374       try {
 375          On_ScrollDownEvt(args);
 376       } catch (Exception e) {
 377          Eina.Log.Error(e.ToString());
 378          Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 379       }
 380    }
 381
 382 private static object ScrollLeftEvtKey = new object();
 383    /// <summary>Called when scrolling left</summary>
 384    public event EventHandler ScrollLeftEvt
 385    {
 386       add {
 387          lock (eventLock) {
 388             string key = "_EFL_UI_EVENT_SCROLL_LEFT";
 389             if (add_cpp_event_handler(efl.Libs.Efl, key, this.evt_ScrollLeftEvt_delegate)) {
 390                eventHandlers.AddHandler(ScrollLeftEvtKey , value);
 391             } else
 392                Eina.Log.Error($"Error adding proxy for event {key}");
 393          }
 394       }
 395       remove {
 396          lock (eventLock) {
 397             string key = "_EFL_UI_EVENT_SCROLL_LEFT";
 398             if (remove_cpp_event_handler(key, this.evt_ScrollLeftEvt_delegate)) {
 399                eventHandlers.RemoveHandler(ScrollLeftEvtKey , value);
 400             } else
 401                Eina.Log.Error($"Error removing proxy for event {key}");
 402          }
 403       }
 404    }
 405    ///<summary>Method to raise event ScrollLeftEvt.</summary>
 406    public void On_ScrollLeftEvt(EventArgs e)
 407    {
 408       EventHandler evt;
 409       lock (eventLock) {
 410       evt = (EventHandler)eventHandlers[ScrollLeftEvtKey];
 411       }
 412       evt?.Invoke(this, e);
 413    }
 414    Efl.EventCb evt_ScrollLeftEvt_delegate;
 415    private void on_ScrollLeftEvt_NativeCallback(System.IntPtr data, ref Efl.Event_StructInternal evt)
 416    {
 417       EventArgs args = EventArgs.Empty;
 418       try {
 419          On_ScrollLeftEvt(args);
 420       } catch (Exception e) {
 421          Eina.Log.Error(e.ToString());
 422          Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 423       }
 424    }
 425
 426 private static object ScrollRightEvtKey = new object();
 427    /// <summary>Called when scrolling right</summary>
 428    public event EventHandler ScrollRightEvt
 429    {
 430       add {
 431          lock (eventLock) {
 432             string key = "_EFL_UI_EVENT_SCROLL_RIGHT";
 433             if (add_cpp_event_handler(efl.Libs.Efl, key, this.evt_ScrollRightEvt_delegate)) {
 434                eventHandlers.AddHandler(ScrollRightEvtKey , value);
 435             } else
 436                Eina.Log.Error($"Error adding proxy for event {key}");
 437          }
 438       }
 439       remove {
 440          lock (eventLock) {
 441             string key = "_EFL_UI_EVENT_SCROLL_RIGHT";
 442             if (remove_cpp_event_handler(key, this.evt_ScrollRightEvt_delegate)) {
 443                eventHandlers.RemoveHandler(ScrollRightEvtKey , value);
 444             } else
 445                Eina.Log.Error($"Error removing proxy for event {key}");
 446          }
 447       }
 448    }
 449    ///<summary>Method to raise event ScrollRightEvt.</summary>
 450    public void On_ScrollRightEvt(EventArgs e)
 451    {
 452       EventHandler evt;
 453       lock (eventLock) {
 454       evt = (EventHandler)eventHandlers[ScrollRightEvtKey];
 455       }
 456       evt?.Invoke(this, e);
 457    }
 458    Efl.EventCb evt_ScrollRightEvt_delegate;
 459    private void on_ScrollRightEvt_NativeCallback(System.IntPtr data, ref Efl.Event_StructInternal evt)
 460    {
 461       EventArgs args = EventArgs.Empty;
 462       try {
 463          On_ScrollRightEvt(args);
 464       } catch (Exception e) {
 465          Eina.Log.Error(e.ToString());
 466          Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 467       }
 468    }
 469
 470 private static object EdgeUpEvtKey = new object();
 471    /// <summary>Called when hitting the top edge</summary>
 472    public event EventHandler EdgeUpEvt
 473    {
 474       add {
 475          lock (eventLock) {
 476             string key = "_EFL_UI_EVENT_EDGE_UP";
 477             if (add_cpp_event_handler(efl.Libs.Efl, key, this.evt_EdgeUpEvt_delegate)) {
 478                eventHandlers.AddHandler(EdgeUpEvtKey , value);
 479             } else
 480                Eina.Log.Error($"Error adding proxy for event {key}");
 481          }
 482       }
 483       remove {
 484          lock (eventLock) {
 485             string key = "_EFL_UI_EVENT_EDGE_UP";
 486             if (remove_cpp_event_handler(key, this.evt_EdgeUpEvt_delegate)) {
 487                eventHandlers.RemoveHandler(EdgeUpEvtKey , value);
 488             } else
 489                Eina.Log.Error($"Error removing proxy for event {key}");
 490          }
 491       }
 492    }
 493    ///<summary>Method to raise event EdgeUpEvt.</summary>
 494    public void On_EdgeUpEvt(EventArgs e)
 495    {
 496       EventHandler evt;
 497       lock (eventLock) {
 498       evt = (EventHandler)eventHandlers[EdgeUpEvtKey];
 499       }
 500       evt?.Invoke(this, e);
 501    }
 502    Efl.EventCb evt_EdgeUpEvt_delegate;
 503    private void on_EdgeUpEvt_NativeCallback(System.IntPtr data, ref Efl.Event_StructInternal evt)
 504    {
 505       EventArgs args = EventArgs.Empty;
 506       try {
 507          On_EdgeUpEvt(args);
 508       } catch (Exception e) {
 509          Eina.Log.Error(e.ToString());
 510          Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 511       }
 512    }
 513
 514 private static object EdgeDownEvtKey = new object();
 515    /// <summary>Called when hitting the bottom edge</summary>
 516    public event EventHandler EdgeDownEvt
 517    {
 518       add {
 519          lock (eventLock) {
 520             string key = "_EFL_UI_EVENT_EDGE_DOWN";
 521             if (add_cpp_event_handler(efl.Libs.Efl, key, this.evt_EdgeDownEvt_delegate)) {
 522                eventHandlers.AddHandler(EdgeDownEvtKey , value);
 523             } else
 524                Eina.Log.Error($"Error adding proxy for event {key}");
 525          }
 526       }
 527       remove {
 528          lock (eventLock) {
 529             string key = "_EFL_UI_EVENT_EDGE_DOWN";
 530             if (remove_cpp_event_handler(key, this.evt_EdgeDownEvt_delegate)) {
 531                eventHandlers.RemoveHandler(EdgeDownEvtKey , value);
 532             } else
 533                Eina.Log.Error($"Error removing proxy for event {key}");
 534          }
 535       }
 536    }
 537    ///<summary>Method to raise event EdgeDownEvt.</summary>
 538    public void On_EdgeDownEvt(EventArgs e)
 539    {
 540       EventHandler evt;
 541       lock (eventLock) {
 542       evt = (EventHandler)eventHandlers[EdgeDownEvtKey];
 543       }
 544       evt?.Invoke(this, e);
 545    }
 546    Efl.EventCb evt_EdgeDownEvt_delegate;
 547    private void on_EdgeDownEvt_NativeCallback(System.IntPtr data, ref Efl.Event_StructInternal evt)
 548    {
 549       EventArgs args = EventArgs.Empty;
 550       try {
 551          On_EdgeDownEvt(args);
 552       } catch (Exception e) {
 553          Eina.Log.Error(e.ToString());
 554          Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 555       }
 556    }
 557
 558 private static object EdgeLeftEvtKey = new object();
 559    /// <summary>Called when hitting the left edge</summary>
 560    public event EventHandler EdgeLeftEvt
 561    {
 562       add {
 563          lock (eventLock) {
 564             string key = "_EFL_UI_EVENT_EDGE_LEFT";
 565             if (add_cpp_event_handler(efl.Libs.Efl, key, this.evt_EdgeLeftEvt_delegate)) {
 566                eventHandlers.AddHandler(EdgeLeftEvtKey , value);
 567             } else
 568                Eina.Log.Error($"Error adding proxy for event {key}");
 569          }
 570       }
 571       remove {
 572          lock (eventLock) {
 573             string key = "_EFL_UI_EVENT_EDGE_LEFT";
 574             if (remove_cpp_event_handler(key, this.evt_EdgeLeftEvt_delegate)) {
 575                eventHandlers.RemoveHandler(EdgeLeftEvtKey , value);
 576             } else
 577                Eina.Log.Error($"Error removing proxy for event {key}");
 578          }
 579       }
 580    }
 581    ///<summary>Method to raise event EdgeLeftEvt.</summary>
 582    public void On_EdgeLeftEvt(EventArgs e)
 583    {
 584       EventHandler evt;
 585       lock (eventLock) {
 586       evt = (EventHandler)eventHandlers[EdgeLeftEvtKey];
 587       }
 588       evt?.Invoke(this, e);
 589    }
 590    Efl.EventCb evt_EdgeLeftEvt_delegate;
 591    private void on_EdgeLeftEvt_NativeCallback(System.IntPtr data, ref Efl.Event_StructInternal evt)
 592    {
 593       EventArgs args = EventArgs.Empty;
 594       try {
 595          On_EdgeLeftEvt(args);
 596       } catch (Exception e) {
 597          Eina.Log.Error(e.ToString());
 598          Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 599       }
 600    }
 601
 602 private static object EdgeRightEvtKey = new object();
 603    /// <summary>Called when hitting the right edge</summary>
 604    public event EventHandler EdgeRightEvt
 605    {
 606       add {
 607          lock (eventLock) {
 608             string key = "_EFL_UI_EVENT_EDGE_RIGHT";
 609             if (add_cpp_event_handler(efl.Libs.Efl, key, this.evt_EdgeRightEvt_delegate)) {
 610                eventHandlers.AddHandler(EdgeRightEvtKey , value);
 611             } else
 612                Eina.Log.Error($"Error adding proxy for event {key}");
 613          }
 614       }
 615       remove {
 616          lock (eventLock) {
 617             string key = "_EFL_UI_EVENT_EDGE_RIGHT";
 618             if (remove_cpp_event_handler(key, this.evt_EdgeRightEvt_delegate)) {
 619                eventHandlers.RemoveHandler(EdgeRightEvtKey , value);
 620             } else
 621                Eina.Log.Error($"Error removing proxy for event {key}");
 622          }
 623       }
 624    }
 625    ///<summary>Method to raise event EdgeRightEvt.</summary>
 626    public void On_EdgeRightEvt(EventArgs e)
 627    {
 628       EventHandler evt;
 629       lock (eventLock) {
 630       evt = (EventHandler)eventHandlers[EdgeRightEvtKey];
 631       }
 632       evt?.Invoke(this, e);
 633    }
 634    Efl.EventCb evt_EdgeRightEvt_delegate;
 635    private void on_EdgeRightEvt_NativeCallback(System.IntPtr data, ref Efl.Event_StructInternal evt)
 636    {
 637       EventArgs args = EventArgs.Empty;
 638       try {
 639          On_EdgeRightEvt(args);
 640       } catch (Exception e) {
 641          Eina.Log.Error(e.ToString());
 642          Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 643       }
 644    }
 645
 646 private static object ScrollAnimStartEvtKey = new object();
 647    /// <summary>Called when scroll animation starts</summary>
 648    public event EventHandler ScrollAnimStartEvt
 649    {
 650       add {
 651          lock (eventLock) {
 652             string key = "_EFL_UI_EVENT_SCROLL_ANIM_START";
 653             if (add_cpp_event_handler(efl.Libs.Efl, key, this.evt_ScrollAnimStartEvt_delegate)) {
 654                eventHandlers.AddHandler(ScrollAnimStartEvtKey , value);
 655             } else
 656                Eina.Log.Error($"Error adding proxy for event {key}");
 657          }
 658       }
 659       remove {
 660          lock (eventLock) {
 661             string key = "_EFL_UI_EVENT_SCROLL_ANIM_START";
 662             if (remove_cpp_event_handler(key, this.evt_ScrollAnimStartEvt_delegate)) {
 663                eventHandlers.RemoveHandler(ScrollAnimStartEvtKey , value);
 664             } else
 665                Eina.Log.Error($"Error removing proxy for event {key}");
 666          }
 667       }
 668    }
 669    ///<summary>Method to raise event ScrollAnimStartEvt.</summary>
 670    public void On_ScrollAnimStartEvt(EventArgs e)
 671    {
 672       EventHandler evt;
 673       lock (eventLock) {
 674       evt = (EventHandler)eventHandlers[ScrollAnimStartEvtKey];
 675       }
 676       evt?.Invoke(this, e);
 677    }
 678    Efl.EventCb evt_ScrollAnimStartEvt_delegate;
 679    private void on_ScrollAnimStartEvt_NativeCallback(System.IntPtr data, ref Efl.Event_StructInternal evt)
 680    {
 681       EventArgs args = EventArgs.Empty;
 682       try {
 683          On_ScrollAnimStartEvt(args);
 684       } catch (Exception e) {
 685          Eina.Log.Error(e.ToString());
 686          Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 687       }
 688    }
 689
 690 private static object ScrollAnimStopEvtKey = new object();
 691    /// <summary>Called when scroll animation stopps</summary>
 692    public event EventHandler ScrollAnimStopEvt
 693    {
 694       add {
 695          lock (eventLock) {
 696             string key = "_EFL_UI_EVENT_SCROLL_ANIM_STOP";
 697             if (add_cpp_event_handler(efl.Libs.Efl, key, this.evt_ScrollAnimStopEvt_delegate)) {
 698                eventHandlers.AddHandler(ScrollAnimStopEvtKey , value);
 699             } else
 700                Eina.Log.Error($"Error adding proxy for event {key}");
 701          }
 702       }
 703       remove {
 704          lock (eventLock) {
 705             string key = "_EFL_UI_EVENT_SCROLL_ANIM_STOP";
 706             if (remove_cpp_event_handler(key, this.evt_ScrollAnimStopEvt_delegate)) {
 707                eventHandlers.RemoveHandler(ScrollAnimStopEvtKey , value);
 708             } else
 709                Eina.Log.Error($"Error removing proxy for event {key}");
 710          }
 711       }
 712    }
 713    ///<summary>Method to raise event ScrollAnimStopEvt.</summary>
 714    public void On_ScrollAnimStopEvt(EventArgs e)
 715    {
 716       EventHandler evt;
 717       lock (eventLock) {
 718       evt = (EventHandler)eventHandlers[ScrollAnimStopEvtKey];
 719       }
 720       evt?.Invoke(this, e);
 721    }
 722    Efl.EventCb evt_ScrollAnimStopEvt_delegate;
 723    private void on_ScrollAnimStopEvt_NativeCallback(System.IntPtr data, ref Efl.Event_StructInternal evt)
 724    {
 725       EventArgs args = EventArgs.Empty;
 726       try {
 727          On_ScrollAnimStopEvt(args);
 728       } catch (Exception e) {
 729          Eina.Log.Error(e.ToString());
 730          Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 731       }
 732    }
 733
 734 private static object ScrollDragStartEvtKey = new object();
 735    /// <summary>Called when scroll drag starts</summary>
 736    public event EventHandler ScrollDragStartEvt
 737    {
 738       add {
 739          lock (eventLock) {
 740             string key = "_EFL_UI_EVENT_SCROLL_DRAG_START";
 741             if (add_cpp_event_handler(efl.Libs.Efl, key, this.evt_ScrollDragStartEvt_delegate)) {
 742                eventHandlers.AddHandler(ScrollDragStartEvtKey , value);
 743             } else
 744                Eina.Log.Error($"Error adding proxy for event {key}");
 745          }
 746       }
 747       remove {
 748          lock (eventLock) {
 749             string key = "_EFL_UI_EVENT_SCROLL_DRAG_START";
 750             if (remove_cpp_event_handler(key, this.evt_ScrollDragStartEvt_delegate)) {
 751                eventHandlers.RemoveHandler(ScrollDragStartEvtKey , value);
 752             } else
 753                Eina.Log.Error($"Error removing proxy for event {key}");
 754          }
 755       }
 756    }
 757    ///<summary>Method to raise event ScrollDragStartEvt.</summary>
 758    public void On_ScrollDragStartEvt(EventArgs e)
 759    {
 760       EventHandler evt;
 761       lock (eventLock) {
 762       evt = (EventHandler)eventHandlers[ScrollDragStartEvtKey];
 763       }
 764       evt?.Invoke(this, e);
 765    }
 766    Efl.EventCb evt_ScrollDragStartEvt_delegate;
 767    private void on_ScrollDragStartEvt_NativeCallback(System.IntPtr data, ref Efl.Event_StructInternal evt)
 768    {
 769       EventArgs args = EventArgs.Empty;
 770       try {
 771          On_ScrollDragStartEvt(args);
 772       } catch (Exception e) {
 773          Eina.Log.Error(e.ToString());
 774          Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 775       }
 776    }
 777
 778 private static object ScrollDragStopEvtKey = new object();
 779    /// <summary>Called when scroll drag stops</summary>
 780    public event EventHandler ScrollDragStopEvt
 781    {
 782       add {
 783          lock (eventLock) {
 784             string key = "_EFL_UI_EVENT_SCROLL_DRAG_STOP";
 785             if (add_cpp_event_handler(efl.Libs.Efl, key, this.evt_ScrollDragStopEvt_delegate)) {
 786                eventHandlers.AddHandler(ScrollDragStopEvtKey , value);
 787             } else
 788                Eina.Log.Error($"Error adding proxy for event {key}");
 789          }
 790       }
 791       remove {
 792          lock (eventLock) {
 793             string key = "_EFL_UI_EVENT_SCROLL_DRAG_STOP";
 794             if (remove_cpp_event_handler(key, this.evt_ScrollDragStopEvt_delegate)) {
 795                eventHandlers.RemoveHandler(ScrollDragStopEvtKey , value);
 796             } else
 797                Eina.Log.Error($"Error removing proxy for event {key}");
 798          }
 799       }
 800    }
 801    ///<summary>Method to raise event ScrollDragStopEvt.</summary>
 802    public void On_ScrollDragStopEvt(EventArgs e)
 803    {
 804       EventHandler evt;
 805       lock (eventLock) {
 806       evt = (EventHandler)eventHandlers[ScrollDragStopEvtKey];
 807       }
 808       evt?.Invoke(this, e);
 809    }
 810    Efl.EventCb evt_ScrollDragStopEvt_delegate;
 811    private void on_ScrollDragStopEvt_NativeCallback(System.IntPtr data, ref Efl.Event_StructInternal evt)
 812    {
 813       EventArgs args = EventArgs.Empty;
 814       try {
 815          On_ScrollDragStopEvt(args);
 816       } catch (Exception e) {
 817          Eina.Log.Error(e.ToString());
 818          Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 819       }
 820    }
 821
 822     void register_event_proxies()
 823    {
 824       evt_ScrollStartEvt_delegate = new Efl.EventCb(on_ScrollStartEvt_NativeCallback);
 825       evt_ScrollEvt_delegate = new Efl.EventCb(on_ScrollEvt_NativeCallback);
 826       evt_ScrollStopEvt_delegate = new Efl.EventCb(on_ScrollStopEvt_NativeCallback);
 827       evt_ScrollUpEvt_delegate = new Efl.EventCb(on_ScrollUpEvt_NativeCallback);
 828       evt_ScrollDownEvt_delegate = new Efl.EventCb(on_ScrollDownEvt_NativeCallback);
 829       evt_ScrollLeftEvt_delegate = new Efl.EventCb(on_ScrollLeftEvt_NativeCallback);
 830       evt_ScrollRightEvt_delegate = new Efl.EventCb(on_ScrollRightEvt_NativeCallback);
 831       evt_EdgeUpEvt_delegate = new Efl.EventCb(on_EdgeUpEvt_NativeCallback);
 832       evt_EdgeDownEvt_delegate = new Efl.EventCb(on_EdgeDownEvt_NativeCallback);
 833       evt_EdgeLeftEvt_delegate = new Efl.EventCb(on_EdgeLeftEvt_NativeCallback);
 834       evt_EdgeRightEvt_delegate = new Efl.EventCb(on_EdgeRightEvt_NativeCallback);
 835       evt_ScrollAnimStartEvt_delegate = new Efl.EventCb(on_ScrollAnimStartEvt_NativeCallback);
 836       evt_ScrollAnimStopEvt_delegate = new Efl.EventCb(on_ScrollAnimStopEvt_NativeCallback);
 837       evt_ScrollDragStartEvt_delegate = new Efl.EventCb(on_ScrollDragStartEvt_NativeCallback);
 838       evt_ScrollDragStopEvt_delegate = new Efl.EventCb(on_ScrollDragStopEvt_NativeCallback);
 839    }
 840 }
 841 public class ScrollableNativeInherit  : Efl.Eo.NativeClass{
 842    public  static Efl.Eo.NativeModule _Module = new Efl.Eo.NativeModule(efl.Libs.Efl);
 843    public override System.Collections.Generic.List<Efl_Op_Description> GetEoOps(System.Type type)
 844    {
 845       var descs = new System.Collections.Generic.List<Efl_Op_Description>();
 846       return descs;
 847    }
 848    public override IntPtr GetEflClass()
 849    {
 850       return Efl.Ui.ScrollableConcrete.efl_ui_scrollable_interface_get();
 851    }
 852    public static  IntPtr GetEflClassStatic()
 853    {
 854       return Efl.Ui.ScrollableConcrete.efl_ui_scrollable_interface_get();
 855    }
 856 }
 857 } }
 858 namespace Efl { namespace Ui {
 859 /// <summary>Direction in which a scroller should be blocked.
 860 /// Note: These options may be effective only in case of thumbscroll (i.e. when scrolling by dragging).
 861 /// 1.21</summary>
 862 public enum ScrollBlock
 863 {
 864 /// <summary>Don&apos;t block any movement.</summary>
 865 None = 0,
 866 /// <summary>Block vertical movement.</summary>
 867 Vertical = 1,
 868 /// <summary>Block horizontal movement.</summary>
 869 Horizontal = 2,
 870 }
 871 } }