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