internals/src/EflSharp/EflSharp/efl_ui_scrollbar.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></summary>
   9 [ScrollbarNativeInherit]
  10 public interface Scrollbar :
  11    Efl.Eo.IWrapper, IDisposable
  12 {
  13    /// <summary>Scrollbar visibility policy</summary>
  14 /// <param name="hbar">Horizontal scrollbar</param>
  15 /// <param name="vbar">Vertical scrollbar</param>
  16 /// <returns></returns>
  17  void GetBarMode( out Efl.Ui.ScrollbarMode hbar,  out Efl.Ui.ScrollbarMode vbar);
  18    /// <summary>Scrollbar visibility policy</summary>
  19 /// <param name="hbar">Horizontal scrollbar</param>
  20 /// <param name="vbar">Vertical scrollbar</param>
  21 /// <returns></returns>
  22  void SetBarMode( Efl.Ui.ScrollbarMode hbar,  Efl.Ui.ScrollbarMode vbar);
  23    /// <summary>Scrollbar size. It is calculated based on viewport size-content sizes.</summary>
  24 /// <param name="width">Value between 0.0 and 1.0</param>
  25 /// <param name="height">Value between 0.0 and 1.0</param>
  26 /// <returns></returns>
  27  void GetBarSize( out double width,  out double height);
  28    /// <summary>Scrollbar position. It is calculated based on current position-maximum positions.</summary>
  29 /// <param name="posx">Value between 0.0 and 1.0</param>
  30 /// <param name="posy">Value between 0.0 and 1.0</param>
  31 /// <returns></returns>
  32  void GetBarPosition( out double posx,  out double posy);
  33    /// <summary>Scrollbar position. It is calculated based on current position-maximum positions.</summary>
  34 /// <param name="posx">Value between 0.0 and 1.0</param>
  35 /// <param name="posy">Value between 0.0 and 1.0</param>
  36 /// <returns></returns>
  37  void SetBarPosition( double posx,  double posy);
  38    /// <summary>Update bar visibility.
  39 /// The object will call this function whenever the bar need to be shown or hidden.</summary>
  40 /// <returns></returns>
  41  void UpdateBarVisibility();
  42                      /// <summary>Called when bar is pressed</summary>
  43    event EventHandler<Efl.Ui.ScrollbarBarPressEvt_Args> BarPressEvt;
  44    /// <summary>Called when bar is unpressed</summary>
  45    event EventHandler<Efl.Ui.ScrollbarBarUnpressEvt_Args> BarUnpressEvt;
  46    /// <summary>Called when bar is dragged</summary>
  47    event EventHandler<Efl.Ui.ScrollbarBarDragEvt_Args> BarDragEvt;
  48    /// <summary>Called when bar size is changed</summary>
  49    event EventHandler BarSizeChangedEvt;
  50    /// <summary>Called when bar position is changed</summary>
  51    event EventHandler BarPosChangedEvt;
  52    /// <summary>Callend when bar is shown</summary>
  53    event EventHandler<Efl.Ui.ScrollbarBarShowEvt_Args> BarShowEvt;
  54    /// <summary>Called when bar is hidden</summary>
  55    event EventHandler<Efl.Ui.ScrollbarBarHideEvt_Args> BarHideEvt;
  56 }
  57 ///<summary>Event argument wrapper for event <see cref="Efl.Ui.Scrollbar.BarPressEvt"/>.</summary>
  58 public class ScrollbarBarPressEvt_Args : EventArgs {
  59    ///<summary>Actual event payload.</summary>
  60    public Efl.Ui.ScrollbarDirection arg { get; set; }
  61 }
  62 ///<summary>Event argument wrapper for event <see cref="Efl.Ui.Scrollbar.BarUnpressEvt"/>.</summary>
  63 public class ScrollbarBarUnpressEvt_Args : EventArgs {
  64    ///<summary>Actual event payload.</summary>
  65    public Efl.Ui.ScrollbarDirection arg { get; set; }
  66 }
  67 ///<summary>Event argument wrapper for event <see cref="Efl.Ui.Scrollbar.BarDragEvt"/>.</summary>
  68 public class ScrollbarBarDragEvt_Args : EventArgs {
  69    ///<summary>Actual event payload.</summary>
  70    public Efl.Ui.ScrollbarDirection arg { get; set; }
  71 }
  72 ///<summary>Event argument wrapper for event <see cref="Efl.Ui.Scrollbar.BarShowEvt"/>.</summary>
  73 public class ScrollbarBarShowEvt_Args : EventArgs {
  74    ///<summary>Actual event payload.</summary>
  75    public Efl.Ui.ScrollbarDirection arg { get; set; }
  76 }
  77 ///<summary>Event argument wrapper for event <see cref="Efl.Ui.Scrollbar.BarHideEvt"/>.</summary>
  78 public class ScrollbarBarHideEvt_Args : EventArgs {
  79    ///<summary>Actual event payload.</summary>
  80    public Efl.Ui.ScrollbarDirection arg { get; set; }
  81 }
  82 /// <summary></summary>
  83 sealed public class ScrollbarConcrete :
  84
  85 Scrollbar
  86
  87 {
  88    ///<summary>Pointer to the native class description.</summary>
  89    public System.IntPtr NativeClass {
  90       get {
  91          if (((object)this).GetType() == typeof (ScrollbarConcrete))
  92             return Efl.Ui.ScrollbarNativeInherit.GetEflClassStatic();
  93          else
  94             return Efl.Eo.ClassRegister.klassFromType[((object)this).GetType()];
  95       }
  96    }
  97    private EventHandlerList eventHandlers = new EventHandlerList();
  98    private  System.IntPtr handle;
  99    ///<summary>Pointer to the native instance.</summary>
 100    public System.IntPtr NativeHandle {
 101       get { return handle; }
 102    }
 103    [System.Runtime.InteropServices.DllImport(efl.Libs.Efl)] internal static extern System.IntPtr
 104       efl_ui_scrollbar_interface_get();
 105    ///<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>
 106    public ScrollbarConcrete(System.IntPtr raw)
 107    {
 108       handle = raw;
 109       register_event_proxies();
 110    }
 111    ///<summary>Destructor.</summary>
 112    ~ScrollbarConcrete()
 113    {
 114       Dispose(false);
 115    }
 116    ///<summary>Releases the underlying native instance.</summary>
 117    void Dispose(bool disposing)
 118    {
 119       if (handle != System.IntPtr.Zero) {
 120          Efl.Eo.Globals.efl_unref(handle);
 121          handle = System.IntPtr.Zero;
 122       }
 123    }
 124    ///<summary>Releases the underlying native instance.</summary>
 125    public void Dispose()
 126    {
 127       Dispose(true);
 128       GC.SuppressFinalize(this);
 129    }
 130    ///<summary>Casts obj into an instance of this type.</summary>
 131    public static ScrollbarConcrete static_cast(Efl.Object obj)
 132    {
 133       if (obj == null)
 134          throw new System.ArgumentNullException("obj");
 135       return new ScrollbarConcrete(obj.NativeHandle);
 136    }
 137    ///<summary>Verifies if the given object is equal to this one.</summary>
 138    public override bool Equals(object obj)
 139    {
 140       var other = obj as Efl.Object;
 141       if (other == null)
 142          return false;
 143       return this.NativeHandle == other.NativeHandle;
 144    }
 145    ///<summary>Gets the hash code for this object based on the native pointer it points to.</summary>
 146    public override int GetHashCode()
 147    {
 148       return this.NativeHandle.ToInt32();
 149    }
 150    ///<summary>Turns the native pointer into a string representation.</summary>
 151    public override String ToString()
 152    {
 153       return $"{this.GetType().Name}@[{this.NativeHandle.ToInt32():x}]";
 154    }
 155    private readonly object eventLock = new object();
 156    private Dictionary<string, int> event_cb_count = new Dictionary<string, int>();
 157    private bool add_cpp_event_handler(string lib, string key, Efl.EventCb evt_delegate) {
 158       int event_count = 0;
 159       if (!event_cb_count.TryGetValue(key, out event_count))
 160          event_cb_count[key] = event_count;
 161       if (event_count == 0) {
 162          IntPtr desc = Efl.EventDescription.GetNative(lib, key);
 163          if (desc == IntPtr.Zero) {
 164             Eina.Log.Error($"Failed to get native event {key}");
 165             return false;
 166          }
 167           bool result = Efl.Eo.Globals.efl_event_callback_priority_add(handle, desc, 0, evt_delegate, System.IntPtr.Zero);
 168          if (!result) {
 169             Eina.Log.Error($"Failed to add event proxy for event {key}");
 170             return false;
 171          }
 172          Eina.Error.RaiseIfUnhandledException();
 173       }
 174       event_cb_count[key]++;
 175       return true;
 176    }
 177    private bool remove_cpp_event_handler(string key, Efl.EventCb evt_delegate) {
 178       int event_count = 0;
 179       if (!event_cb_count.TryGetValue(key, out event_count))
 180          event_cb_count[key] = event_count;
 181       if (event_count == 1) {
 182          IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
 183          if (desc == IntPtr.Zero) {
 184             Eina.Log.Error($"Failed to get native event {key}");
 185             return false;
 186          }
 187          bool result = Efl.Eo.Globals.efl_event_callback_del(handle, desc, evt_delegate, System.IntPtr.Zero);
 188          if (!result) {
 189             Eina.Log.Error($"Failed to remove event proxy for event {key}");
 190             return false;
 191          }
 192          Eina.Error.RaiseIfUnhandledException();
 193       } else if (event_count == 0) {
 194          Eina.Log.Error($"Trying to remove proxy for event {key} when there is nothing registered.");
 195          return false;
 196       }
 197       event_cb_count[key]--;
 198       return true;
 199    }
 200 private static object BarPressEvtKey = new object();
 201    /// <summary>Called when bar is pressed</summary>
 202    public event EventHandler<Efl.Ui.ScrollbarBarPressEvt_Args> BarPressEvt
 203    {
 204       add {
 205          lock (eventLock) {
 206             string key = "_EFL_UI_SCROLLBAR_EVENT_BAR_PRESS";
 207             if (add_cpp_event_handler(efl.Libs.Efl, key, this.evt_BarPressEvt_delegate)) {
 208                eventHandlers.AddHandler(BarPressEvtKey , 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_SCROLLBAR_EVENT_BAR_PRESS";
 216             if (remove_cpp_event_handler(key, this.evt_BarPressEvt_delegate)) {
 217                eventHandlers.RemoveHandler(BarPressEvtKey , value);
 218             } else
 219                Eina.Log.Error($"Error removing proxy for event {key}");
 220          }
 221       }
 222    }
 223    ///<summary>Method to raise event BarPressEvt.</summary>
 224    public void On_BarPressEvt(Efl.Ui.ScrollbarBarPressEvt_Args e)
 225    {
 226       EventHandler<Efl.Ui.ScrollbarBarPressEvt_Args> evt;
 227       lock (eventLock) {
 228       evt = (EventHandler<Efl.Ui.ScrollbarBarPressEvt_Args>)eventHandlers[BarPressEvtKey];
 229       }
 230       evt?.Invoke(this, e);
 231    }
 232    Efl.EventCb evt_BarPressEvt_delegate;
 233    private void on_BarPressEvt_NativeCallback(System.IntPtr data, ref Efl.Event_StructInternal evt)
 234    {
 235       Efl.Ui.ScrollbarBarPressEvt_Args args = new Efl.Ui.ScrollbarBarPressEvt_Args();
 236       args.arg = default(Efl.Ui.ScrollbarDirection);
 237       try {
 238          On_BarPressEvt(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 BarUnpressEvtKey = new object();
 246    /// <summary>Called when bar is unpressed</summary>
 247    public event EventHandler<Efl.Ui.ScrollbarBarUnpressEvt_Args> BarUnpressEvt
 248    {
 249       add {
 250          lock (eventLock) {
 251             string key = "_EFL_UI_SCROLLBAR_EVENT_BAR_UNPRESS";
 252             if (add_cpp_event_handler(efl.Libs.Efl, key, this.evt_BarUnpressEvt_delegate)) {
 253                eventHandlers.AddHandler(BarUnpressEvtKey , 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_SCROLLBAR_EVENT_BAR_UNPRESS";
 261             if (remove_cpp_event_handler(key, this.evt_BarUnpressEvt_delegate)) {
 262                eventHandlers.RemoveHandler(BarUnpressEvtKey , value);
 263             } else
 264                Eina.Log.Error($"Error removing proxy for event {key}");
 265          }
 266       }
 267    }
 268    ///<summary>Method to raise event BarUnpressEvt.</summary>
 269    public void On_BarUnpressEvt(Efl.Ui.ScrollbarBarUnpressEvt_Args e)
 270    {
 271       EventHandler<Efl.Ui.ScrollbarBarUnpressEvt_Args> evt;
 272       lock (eventLock) {
 273       evt = (EventHandler<Efl.Ui.ScrollbarBarUnpressEvt_Args>)eventHandlers[BarUnpressEvtKey];
 274       }
 275       evt?.Invoke(this, e);
 276    }
 277    Efl.EventCb evt_BarUnpressEvt_delegate;
 278    private void on_BarUnpressEvt_NativeCallback(System.IntPtr data, ref Efl.Event_StructInternal evt)
 279    {
 280       Efl.Ui.ScrollbarBarUnpressEvt_Args args = new Efl.Ui.ScrollbarBarUnpressEvt_Args();
 281       args.arg = default(Efl.Ui.ScrollbarDirection);
 282       try {
 283          On_BarUnpressEvt(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 BarDragEvtKey = new object();
 291    /// <summary>Called when bar is dragged</summary>
 292    public event EventHandler<Efl.Ui.ScrollbarBarDragEvt_Args> BarDragEvt
 293    {
 294       add {
 295          lock (eventLock) {
 296             string key = "_EFL_UI_SCROLLBAR_EVENT_BAR_DRAG";
 297             if (add_cpp_event_handler(efl.Libs.Efl, key, this.evt_BarDragEvt_delegate)) {
 298                eventHandlers.AddHandler(BarDragEvtKey , 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_SCROLLBAR_EVENT_BAR_DRAG";
 306             if (remove_cpp_event_handler(key, this.evt_BarDragEvt_delegate)) {
 307                eventHandlers.RemoveHandler(BarDragEvtKey , value);
 308             } else
 309                Eina.Log.Error($"Error removing proxy for event {key}");
 310          }
 311       }
 312    }
 313    ///<summary>Method to raise event BarDragEvt.</summary>
 314    public void On_BarDragEvt(Efl.Ui.ScrollbarBarDragEvt_Args e)
 315    {
 316       EventHandler<Efl.Ui.ScrollbarBarDragEvt_Args> evt;
 317       lock (eventLock) {
 318       evt = (EventHandler<Efl.Ui.ScrollbarBarDragEvt_Args>)eventHandlers[BarDragEvtKey];
 319       }
 320       evt?.Invoke(this, e);
 321    }
 322    Efl.EventCb evt_BarDragEvt_delegate;
 323    private void on_BarDragEvt_NativeCallback(System.IntPtr data, ref Efl.Event_StructInternal evt)
 324    {
 325       Efl.Ui.ScrollbarBarDragEvt_Args args = new Efl.Ui.ScrollbarBarDragEvt_Args();
 326       args.arg = default(Efl.Ui.ScrollbarDirection);
 327       try {
 328          On_BarDragEvt(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 BarSizeChangedEvtKey = new object();
 336    /// <summary>Called when bar size is changed</summary>
 337    public event EventHandler BarSizeChangedEvt
 338    {
 339       add {
 340          lock (eventLock) {
 341             string key = "_EFL_UI_SCROLLBAR_EVENT_BAR_SIZE_CHANGED";
 342             if (add_cpp_event_handler(efl.Libs.Efl, key, this.evt_BarSizeChangedEvt_delegate)) {
 343                eventHandlers.AddHandler(BarSizeChangedEvtKey , 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_SCROLLBAR_EVENT_BAR_SIZE_CHANGED";
 351             if (remove_cpp_event_handler(key, this.evt_BarSizeChangedEvt_delegate)) {
 352                eventHandlers.RemoveHandler(BarSizeChangedEvtKey , value);
 353             } else
 354                Eina.Log.Error($"Error removing proxy for event {key}");
 355          }
 356       }
 357    }
 358    ///<summary>Method to raise event BarSizeChangedEvt.</summary>
 359    public void On_BarSizeChangedEvt(EventArgs e)
 360    {
 361       EventHandler evt;
 362       lock (eventLock) {
 363       evt = (EventHandler)eventHandlers[BarSizeChangedEvtKey];
 364       }
 365       evt?.Invoke(this, e);
 366    }
 367    Efl.EventCb evt_BarSizeChangedEvt_delegate;
 368    private void on_BarSizeChangedEvt_NativeCallback(System.IntPtr data, ref Efl.Event_StructInternal evt)
 369    {
 370       EventArgs args = EventArgs.Empty;
 371       try {
 372          On_BarSizeChangedEvt(args);
 373       } catch (Exception e) {
 374          Eina.Log.Error(e.ToString());
 375          Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 376       }
 377    }
 378
 379 private static object BarPosChangedEvtKey = new object();
 380    /// <summary>Called when bar position is changed</summary>
 381    public event EventHandler BarPosChangedEvt
 382    {
 383       add {
 384          lock (eventLock) {
 385             string key = "_EFL_UI_SCROLLBAR_EVENT_BAR_POS_CHANGED";
 386             if (add_cpp_event_handler(efl.Libs.Efl, key, this.evt_BarPosChangedEvt_delegate)) {
 387                eventHandlers.AddHandler(BarPosChangedEvtKey , value);
 388             } else
 389                Eina.Log.Error($"Error adding proxy for event {key}");
 390          }
 391       }
 392       remove {
 393          lock (eventLock) {
 394             string key = "_EFL_UI_SCROLLBAR_EVENT_BAR_POS_CHANGED";
 395             if (remove_cpp_event_handler(key, this.evt_BarPosChangedEvt_delegate)) {
 396                eventHandlers.RemoveHandler(BarPosChangedEvtKey , value);
 397             } else
 398                Eina.Log.Error($"Error removing proxy for event {key}");
 399          }
 400       }
 401    }
 402    ///<summary>Method to raise event BarPosChangedEvt.</summary>
 403    public void On_BarPosChangedEvt(EventArgs e)
 404    {
 405       EventHandler evt;
 406       lock (eventLock) {
 407       evt = (EventHandler)eventHandlers[BarPosChangedEvtKey];
 408       }
 409       evt?.Invoke(this, e);
 410    }
 411    Efl.EventCb evt_BarPosChangedEvt_delegate;
 412    private void on_BarPosChangedEvt_NativeCallback(System.IntPtr data, ref Efl.Event_StructInternal evt)
 413    {
 414       EventArgs args = EventArgs.Empty;
 415       try {
 416          On_BarPosChangedEvt(args);
 417       } catch (Exception e) {
 418          Eina.Log.Error(e.ToString());
 419          Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 420       }
 421    }
 422
 423 private static object BarShowEvtKey = new object();
 424    /// <summary>Callend when bar is shown</summary>
 425    public event EventHandler<Efl.Ui.ScrollbarBarShowEvt_Args> BarShowEvt
 426    {
 427       add {
 428          lock (eventLock) {
 429             string key = "_EFL_UI_SCROLLBAR_EVENT_BAR_SHOW";
 430             if (add_cpp_event_handler(efl.Libs.Efl, key, this.evt_BarShowEvt_delegate)) {
 431                eventHandlers.AddHandler(BarShowEvtKey , value);
 432             } else
 433                Eina.Log.Error($"Error adding proxy for event {key}");
 434          }
 435       }
 436       remove {
 437          lock (eventLock) {
 438             string key = "_EFL_UI_SCROLLBAR_EVENT_BAR_SHOW";
 439             if (remove_cpp_event_handler(key, this.evt_BarShowEvt_delegate)) {
 440                eventHandlers.RemoveHandler(BarShowEvtKey , value);
 441             } else
 442                Eina.Log.Error($"Error removing proxy for event {key}");
 443          }
 444       }
 445    }
 446    ///<summary>Method to raise event BarShowEvt.</summary>
 447    public void On_BarShowEvt(Efl.Ui.ScrollbarBarShowEvt_Args e)
 448    {
 449       EventHandler<Efl.Ui.ScrollbarBarShowEvt_Args> evt;
 450       lock (eventLock) {
 451       evt = (EventHandler<Efl.Ui.ScrollbarBarShowEvt_Args>)eventHandlers[BarShowEvtKey];
 452       }
 453       evt?.Invoke(this, e);
 454    }
 455    Efl.EventCb evt_BarShowEvt_delegate;
 456    private void on_BarShowEvt_NativeCallback(System.IntPtr data, ref Efl.Event_StructInternal evt)
 457    {
 458       Efl.Ui.ScrollbarBarShowEvt_Args args = new Efl.Ui.ScrollbarBarShowEvt_Args();
 459       args.arg = default(Efl.Ui.ScrollbarDirection);
 460       try {
 461          On_BarShowEvt(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 BarHideEvtKey = new object();
 469    /// <summary>Called when bar is hidden</summary>
 470    public event EventHandler<Efl.Ui.ScrollbarBarHideEvt_Args> BarHideEvt
 471    {
 472       add {
 473          lock (eventLock) {
 474             string key = "_EFL_UI_SCROLLBAR_EVENT_BAR_HIDE";
 475             if (add_cpp_event_handler(efl.Libs.Efl, key, this.evt_BarHideEvt_delegate)) {
 476                eventHandlers.AddHandler(BarHideEvtKey , 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_SCROLLBAR_EVENT_BAR_HIDE";
 484             if (remove_cpp_event_handler(key, this.evt_BarHideEvt_delegate)) {
 485                eventHandlers.RemoveHandler(BarHideEvtKey , value);
 486             } else
 487                Eina.Log.Error($"Error removing proxy for event {key}");
 488          }
 489       }
 490    }
 491    ///<summary>Method to raise event BarHideEvt.</summary>
 492    public void On_BarHideEvt(Efl.Ui.ScrollbarBarHideEvt_Args e)
 493    {
 494       EventHandler<Efl.Ui.ScrollbarBarHideEvt_Args> evt;
 495       lock (eventLock) {
 496       evt = (EventHandler<Efl.Ui.ScrollbarBarHideEvt_Args>)eventHandlers[BarHideEvtKey];
 497       }
 498       evt?.Invoke(this, e);
 499    }
 500    Efl.EventCb evt_BarHideEvt_delegate;
 501    private void on_BarHideEvt_NativeCallback(System.IntPtr data, ref Efl.Event_StructInternal evt)
 502    {
 503       Efl.Ui.ScrollbarBarHideEvt_Args args = new Efl.Ui.ScrollbarBarHideEvt_Args();
 504       args.arg = default(Efl.Ui.ScrollbarDirection);
 505       try {
 506          On_BarHideEvt(args);
 507       } catch (Exception e) {
 508          Eina.Log.Error(e.ToString());
 509          Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 510       }
 511    }
 512
 513     void register_event_proxies()
 514    {
 515       evt_BarPressEvt_delegate = new Efl.EventCb(on_BarPressEvt_NativeCallback);
 516       evt_BarUnpressEvt_delegate = new Efl.EventCb(on_BarUnpressEvt_NativeCallback);
 517       evt_BarDragEvt_delegate = new Efl.EventCb(on_BarDragEvt_NativeCallback);
 518       evt_BarSizeChangedEvt_delegate = new Efl.EventCb(on_BarSizeChangedEvt_NativeCallback);
 519       evt_BarPosChangedEvt_delegate = new Efl.EventCb(on_BarPosChangedEvt_NativeCallback);
 520       evt_BarShowEvt_delegate = new Efl.EventCb(on_BarShowEvt_NativeCallback);
 521       evt_BarHideEvt_delegate = new Efl.EventCb(on_BarHideEvt_NativeCallback);
 522    }
 523    /// <summary>Scrollbar visibility policy</summary>
 524    /// <param name="hbar">Horizontal scrollbar</param>
 525    /// <param name="vbar">Vertical scrollbar</param>
 526    /// <returns></returns>
 527    public  void GetBarMode( out Efl.Ui.ScrollbarMode hbar,  out Efl.Ui.ScrollbarMode vbar) {
 528                                            Efl.Ui.ScrollbarNativeInherit.efl_ui_scrollbar_bar_mode_get_ptr.Value.Delegate(this.NativeHandle, out hbar,  out vbar);
 529       Eina.Error.RaiseIfUnhandledException();
 530                                }
 531    /// <summary>Scrollbar visibility policy</summary>
 532    /// <param name="hbar">Horizontal scrollbar</param>
 533    /// <param name="vbar">Vertical scrollbar</param>
 534    /// <returns></returns>
 535    public  void SetBarMode( Efl.Ui.ScrollbarMode hbar,  Efl.Ui.ScrollbarMode vbar) {
 536                                            Efl.Ui.ScrollbarNativeInherit.efl_ui_scrollbar_bar_mode_set_ptr.Value.Delegate(this.NativeHandle, hbar,  vbar);
 537       Eina.Error.RaiseIfUnhandledException();
 538                                }
 539    /// <summary>Scrollbar size. It is calculated based on viewport size-content sizes.</summary>
 540    /// <param name="width">Value between 0.0 and 1.0</param>
 541    /// <param name="height">Value between 0.0 and 1.0</param>
 542    /// <returns></returns>
 543    public  void GetBarSize( out double width,  out double height) {
 544                                            Efl.Ui.ScrollbarNativeInherit.efl_ui_scrollbar_bar_size_get_ptr.Value.Delegate(this.NativeHandle, out width,  out height);
 545       Eina.Error.RaiseIfUnhandledException();
 546                                }
 547    /// <summary>Scrollbar position. It is calculated based on current position-maximum positions.</summary>
 548    /// <param name="posx">Value between 0.0 and 1.0</param>
 549    /// <param name="posy">Value between 0.0 and 1.0</param>
 550    /// <returns></returns>
 551    public  void GetBarPosition( out double posx,  out double posy) {
 552                                            Efl.Ui.ScrollbarNativeInherit.efl_ui_scrollbar_bar_position_get_ptr.Value.Delegate(this.NativeHandle, out posx,  out posy);
 553       Eina.Error.RaiseIfUnhandledException();
 554                                }
 555    /// <summary>Scrollbar position. It is calculated based on current position-maximum positions.</summary>
 556    /// <param name="posx">Value between 0.0 and 1.0</param>
 557    /// <param name="posy">Value between 0.0 and 1.0</param>
 558    /// <returns></returns>
 559    public  void SetBarPosition( double posx,  double posy) {
 560                                            Efl.Ui.ScrollbarNativeInherit.efl_ui_scrollbar_bar_position_set_ptr.Value.Delegate(this.NativeHandle, posx,  posy);
 561       Eina.Error.RaiseIfUnhandledException();
 562                                }
 563    /// <summary>Update bar visibility.
 564    /// The object will call this function whenever the bar need to be shown or hidden.</summary>
 565    /// <returns></returns>
 566    public  void UpdateBarVisibility() {
 567        Efl.Ui.ScrollbarNativeInherit.efl_ui_scrollbar_bar_visibility_update_ptr.Value.Delegate(this.NativeHandle);
 568       Eina.Error.RaiseIfUnhandledException();
 569        }
 570 }
 571 public class ScrollbarNativeInherit  : Efl.Eo.NativeClass{
 572    public  static Efl.Eo.NativeModule _Module = new Efl.Eo.NativeModule(efl.Libs.Efl);
 573    public override System.Collections.Generic.List<Efl_Op_Description> GetEoOps(System.Type type)
 574    {
 575       var descs = new System.Collections.Generic.List<Efl_Op_Description>();
 576       if (efl_ui_scrollbar_bar_mode_get_static_delegate == null)
 577       efl_ui_scrollbar_bar_mode_get_static_delegate = new efl_ui_scrollbar_bar_mode_get_delegate(bar_mode_get);
 578       descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_ui_scrollbar_bar_mode_get"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_scrollbar_bar_mode_get_static_delegate)});
 579       if (efl_ui_scrollbar_bar_mode_set_static_delegate == null)
 580       efl_ui_scrollbar_bar_mode_set_static_delegate = new efl_ui_scrollbar_bar_mode_set_delegate(bar_mode_set);
 581       descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_ui_scrollbar_bar_mode_set"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_scrollbar_bar_mode_set_static_delegate)});
 582       if (efl_ui_scrollbar_bar_size_get_static_delegate == null)
 583       efl_ui_scrollbar_bar_size_get_static_delegate = new efl_ui_scrollbar_bar_size_get_delegate(bar_size_get);
 584       descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_ui_scrollbar_bar_size_get"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_scrollbar_bar_size_get_static_delegate)});
 585       if (efl_ui_scrollbar_bar_position_get_static_delegate == null)
 586       efl_ui_scrollbar_bar_position_get_static_delegate = new efl_ui_scrollbar_bar_position_get_delegate(bar_position_get);
 587       descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_ui_scrollbar_bar_position_get"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_scrollbar_bar_position_get_static_delegate)});
 588       if (efl_ui_scrollbar_bar_position_set_static_delegate == null)
 589       efl_ui_scrollbar_bar_position_set_static_delegate = new efl_ui_scrollbar_bar_position_set_delegate(bar_position_set);
 590       descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_ui_scrollbar_bar_position_set"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_scrollbar_bar_position_set_static_delegate)});
 591       if (efl_ui_scrollbar_bar_visibility_update_static_delegate == null)
 592       efl_ui_scrollbar_bar_visibility_update_static_delegate = new efl_ui_scrollbar_bar_visibility_update_delegate(bar_visibility_update);
 593       descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_ui_scrollbar_bar_visibility_update"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_scrollbar_bar_visibility_update_static_delegate)});
 594       return descs;
 595    }
 596    public override IntPtr GetEflClass()
 597    {
 598       return Efl.Ui.ScrollbarConcrete.efl_ui_scrollbar_interface_get();
 599    }
 600    public static  IntPtr GetEflClassStatic()
 601    {
 602       return Efl.Ui.ScrollbarConcrete.efl_ui_scrollbar_interface_get();
 603    }
 604
 605
 606     private delegate  void efl_ui_scrollbar_bar_mode_get_delegate(System.IntPtr obj, System.IntPtr pd,   out Efl.Ui.ScrollbarMode hbar,   out Efl.Ui.ScrollbarMode vbar);
 607
 608
 609     public delegate  void efl_ui_scrollbar_bar_mode_get_api_delegate(System.IntPtr obj,   out Efl.Ui.ScrollbarMode hbar,   out Efl.Ui.ScrollbarMode vbar);
 610     public static Efl.Eo.FunctionWrapper<efl_ui_scrollbar_bar_mode_get_api_delegate> efl_ui_scrollbar_bar_mode_get_ptr = new Efl.Eo.FunctionWrapper<efl_ui_scrollbar_bar_mode_get_api_delegate>(_Module, "efl_ui_scrollbar_bar_mode_get");
 611     private static  void bar_mode_get(System.IntPtr obj, System.IntPtr pd,  out Efl.Ui.ScrollbarMode hbar,  out Efl.Ui.ScrollbarMode vbar)
 612    {
 613       Eina.Log.Debug("function efl_ui_scrollbar_bar_mode_get was called");
 614       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
 615       if(wrapper != null) {
 616                            hbar = default(Efl.Ui.ScrollbarMode);      vbar = default(Efl.Ui.ScrollbarMode);
 617          try {
 618             ((Scrollbar)wrapper).GetBarMode( out hbar,  out vbar);
 619          } catch (Exception e) {
 620             Eina.Log.Warning($"Callback error: {e.ToString()}");
 621             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 622          }
 623                                     } else {
 624          efl_ui_scrollbar_bar_mode_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  out hbar,  out vbar);
 625       }
 626    }
 627    private static efl_ui_scrollbar_bar_mode_get_delegate efl_ui_scrollbar_bar_mode_get_static_delegate;
 628
 629
 630     private delegate  void efl_ui_scrollbar_bar_mode_set_delegate(System.IntPtr obj, System.IntPtr pd,   Efl.Ui.ScrollbarMode hbar,   Efl.Ui.ScrollbarMode vbar);
 631
 632
 633     public delegate  void efl_ui_scrollbar_bar_mode_set_api_delegate(System.IntPtr obj,   Efl.Ui.ScrollbarMode hbar,   Efl.Ui.ScrollbarMode vbar);
 634     public static Efl.Eo.FunctionWrapper<efl_ui_scrollbar_bar_mode_set_api_delegate> efl_ui_scrollbar_bar_mode_set_ptr = new Efl.Eo.FunctionWrapper<efl_ui_scrollbar_bar_mode_set_api_delegate>(_Module, "efl_ui_scrollbar_bar_mode_set");
 635     private static  void bar_mode_set(System.IntPtr obj, System.IntPtr pd,  Efl.Ui.ScrollbarMode hbar,  Efl.Ui.ScrollbarMode vbar)
 636    {
 637       Eina.Log.Debug("function efl_ui_scrollbar_bar_mode_set was called");
 638       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
 639       if(wrapper != null) {
 640
 641          try {
 642             ((Scrollbar)wrapper).SetBarMode( hbar,  vbar);
 643          } catch (Exception e) {
 644             Eina.Log.Warning($"Callback error: {e.ToString()}");
 645             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 646          }
 647                                     } else {
 648          efl_ui_scrollbar_bar_mode_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  hbar,  vbar);
 649       }
 650    }
 651    private static efl_ui_scrollbar_bar_mode_set_delegate efl_ui_scrollbar_bar_mode_set_static_delegate;
 652
 653
 654     private delegate  void efl_ui_scrollbar_bar_size_get_delegate(System.IntPtr obj, System.IntPtr pd,   out double width,   out double height);
 655
 656
 657     public delegate  void efl_ui_scrollbar_bar_size_get_api_delegate(System.IntPtr obj,   out double width,   out double height);
 658     public static Efl.Eo.FunctionWrapper<efl_ui_scrollbar_bar_size_get_api_delegate> efl_ui_scrollbar_bar_size_get_ptr = new Efl.Eo.FunctionWrapper<efl_ui_scrollbar_bar_size_get_api_delegate>(_Module, "efl_ui_scrollbar_bar_size_get");
 659     private static  void bar_size_get(System.IntPtr obj, System.IntPtr pd,  out double width,  out double height)
 660    {
 661       Eina.Log.Debug("function efl_ui_scrollbar_bar_size_get was called");
 662       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
 663       if(wrapper != null) {
 664                            width = default(double);      height = default(double);
 665          try {
 666             ((Scrollbar)wrapper).GetBarSize( out width,  out height);
 667          } catch (Exception e) {
 668             Eina.Log.Warning($"Callback error: {e.ToString()}");
 669             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 670          }
 671                                     } else {
 672          efl_ui_scrollbar_bar_size_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  out width,  out height);
 673       }
 674    }
 675    private static efl_ui_scrollbar_bar_size_get_delegate efl_ui_scrollbar_bar_size_get_static_delegate;
 676
 677
 678     private delegate  void efl_ui_scrollbar_bar_position_get_delegate(System.IntPtr obj, System.IntPtr pd,   out double posx,   out double posy);
 679
 680
 681     public delegate  void efl_ui_scrollbar_bar_position_get_api_delegate(System.IntPtr obj,   out double posx,   out double posy);
 682     public static Efl.Eo.FunctionWrapper<efl_ui_scrollbar_bar_position_get_api_delegate> efl_ui_scrollbar_bar_position_get_ptr = new Efl.Eo.FunctionWrapper<efl_ui_scrollbar_bar_position_get_api_delegate>(_Module, "efl_ui_scrollbar_bar_position_get");
 683     private static  void bar_position_get(System.IntPtr obj, System.IntPtr pd,  out double posx,  out double posy)
 684    {
 685       Eina.Log.Debug("function efl_ui_scrollbar_bar_position_get was called");
 686       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
 687       if(wrapper != null) {
 688                            posx = default(double);      posy = default(double);
 689          try {
 690             ((Scrollbar)wrapper).GetBarPosition( out posx,  out posy);
 691          } catch (Exception e) {
 692             Eina.Log.Warning($"Callback error: {e.ToString()}");
 693             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 694          }
 695                                     } else {
 696          efl_ui_scrollbar_bar_position_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  out posx,  out posy);
 697       }
 698    }
 699    private static efl_ui_scrollbar_bar_position_get_delegate efl_ui_scrollbar_bar_position_get_static_delegate;
 700
 701
 702     private delegate  void efl_ui_scrollbar_bar_position_set_delegate(System.IntPtr obj, System.IntPtr pd,   double posx,   double posy);
 703
 704
 705     public delegate  void efl_ui_scrollbar_bar_position_set_api_delegate(System.IntPtr obj,   double posx,   double posy);
 706     public static Efl.Eo.FunctionWrapper<efl_ui_scrollbar_bar_position_set_api_delegate> efl_ui_scrollbar_bar_position_set_ptr = new Efl.Eo.FunctionWrapper<efl_ui_scrollbar_bar_position_set_api_delegate>(_Module, "efl_ui_scrollbar_bar_position_set");
 707     private static  void bar_position_set(System.IntPtr obj, System.IntPtr pd,  double posx,  double posy)
 708    {
 709       Eina.Log.Debug("function efl_ui_scrollbar_bar_position_set was called");
 710       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
 711       if(wrapper != null) {
 712
 713          try {
 714             ((Scrollbar)wrapper).SetBarPosition( posx,  posy);
 715          } catch (Exception e) {
 716             Eina.Log.Warning($"Callback error: {e.ToString()}");
 717             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 718          }
 719                                     } else {
 720          efl_ui_scrollbar_bar_position_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  posx,  posy);
 721       }
 722    }
 723    private static efl_ui_scrollbar_bar_position_set_delegate efl_ui_scrollbar_bar_position_set_static_delegate;
 724
 725
 726     private delegate  void efl_ui_scrollbar_bar_visibility_update_delegate(System.IntPtr obj, System.IntPtr pd);
 727
 728
 729     public delegate  void efl_ui_scrollbar_bar_visibility_update_api_delegate(System.IntPtr obj);
 730     public static Efl.Eo.FunctionWrapper<efl_ui_scrollbar_bar_visibility_update_api_delegate> efl_ui_scrollbar_bar_visibility_update_ptr = new Efl.Eo.FunctionWrapper<efl_ui_scrollbar_bar_visibility_update_api_delegate>(_Module, "efl_ui_scrollbar_bar_visibility_update");
 731     private static  void bar_visibility_update(System.IntPtr obj, System.IntPtr pd)
 732    {
 733       Eina.Log.Debug("function efl_ui_scrollbar_bar_visibility_update was called");
 734       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
 735       if(wrapper != null) {
 736
 737          try {
 738             ((Scrollbar)wrapper).UpdateBarVisibility();
 739          } catch (Exception e) {
 740             Eina.Log.Warning($"Callback error: {e.ToString()}");
 741             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 742          }
 743             } else {
 744          efl_ui_scrollbar_bar_visibility_update_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
 745       }
 746    }
 747    private static efl_ui_scrollbar_bar_visibility_update_delegate efl_ui_scrollbar_bar_visibility_update_static_delegate;
 748 }
 749 } }
 750 namespace Efl { namespace Ui {
 751 /// <summary></summary>
 752 public enum ScrollbarMode
 753 {
 754 /// <summary>Visible if necessary</summary>
 755 Auto = 0,
 756 /// <summary>Always visible</summary>
 757 On = 1,
 758 /// <summary>Always invisible</summary>
 759 Off = 2,
 760 /// <summary>For internal use only</summary>
 761 Last = 3,
 762 }
 763 } }
 764 namespace Efl { namespace Ui {
 765 /// <summary></summary>
 766 public enum ScrollbarDirection
 767 {
 768 /// <summary></summary>
 769 Horizontal = 0,
 770 /// <summary></summary>
 771 Vertical = 1,
 772 /// <summary></summary>
 773 Last = 2,
 774 }
 775 } }