internals/src/EflSharp/EflSharp/efl/efl_ui_panes.eo.cs

   1 #define EFL_BETA
   2 #pragma warning disable CS1591
   3 using System;
   4 using System.Runtime.InteropServices;
   5 using System.Collections.Generic;
   6 using System.Linq;
   7 using System.Threading;
   8 using System.ComponentModel;
   9 namespace Efl {
  10
  11 namespace Ui {
  12
  13 /// <summary>Elementary panes class</summary>
  14 /// <remarks>This is a <b>BETA</b> class. It can be modified or removed in the future. Do not use it for product development.</remarks>
  15 [Efl.Ui.Panes.NativeMethods]
  16 [Efl.Eo.BindingEntity]
  17 public class Panes : Efl.Ui.LayoutBase, Efl.Input.IClickable, Efl.Ui.ILayoutOrientable
  18 {
  19     /// <summary>Pointer to the native class description.</summary>
  20     public override System.IntPtr NativeClass
  21     {
  22         get
  23         {
  24             if (((object)this).GetType() == typeof(Panes))
  25             {
  26                 return GetEflClassStatic();
  27             }
  28             else
  29             {
  30                 return Efl.Eo.ClassRegister.klassFromType[((object)this).GetType()];
  31             }
  32         }
  33     }
  34
  35     [System.Runtime.InteropServices.DllImport(efl.Libs.Elementary)] internal static extern System.IntPtr
  36         efl_ui_panes_class_get();
  37     /// <summary>Initializes a new instance of the <see cref="Panes"/> class.</summary>
  38     /// <param name="parent">Parent instance.</param>
  39     /// <param name="style">The widget style to use. See <see cref="Efl.Ui.Widget.SetStyle" /></param>
  40     public Panes(Efl.Object parent
  41             , System.String style = null) : base(efl_ui_panes_class_get(), parent)
  42     {
  43         if (Efl.Eo.Globals.ParamHelperCheck(style))
  44         {
  45             SetStyle(Efl.Eo.Globals.GetParamHelper(style));
  46         }
  47
  48         FinishInstantiation();
  49     }
  50
  51     /// <summary>Subclasses should override this constructor if they are expected to be instantiated from native code.
  52     /// Do not call this constructor directly.</summary>
  53     /// <param name="ch">Tag struct storing the native handle of the object being constructed.</param>
  54     protected Panes(ConstructingHandle ch) : base(ch)
  55     {
  56     }
  57
  58     /// <summary>Initializes a new instance of the <see cref="Panes"/> class.
  59     /// Internal usage: Constructs an instance from a native pointer. This is used when interacting with C code and should not be used directly.</summary>
  60     /// <param name="wh">The native pointer to be wrapped.</param>
  61     protected Panes(Efl.Eo.Globals.WrappingHandle wh) : base(wh)
  62     {
  63     }
  64
  65     /// <summary>Initializes a new instance of the <see cref="Panes"/> class.
  66     /// Internal usage: Constructor to forward the wrapper initialization to the root class that interfaces with native code. Should not be used directly.</summary>
  67     /// <param name="baseKlass">The pointer to the base native Eo class.</param>
  68     /// <param name="parent">The Efl.Object parent of this instance.</param>
  69     protected Panes(IntPtr baseKlass, Efl.Object parent) : base(baseKlass, parent)
  70     {
  71     }
  72
  73     /// <summary>Called when panes got pressed</summary>
  74     public event EventHandler PressEvt
  75     {
  76         add
  77         {
  78             lock (eflBindingEventLock)
  79             {
  80                 Efl.EventCb callerCb = (IntPtr data, ref Efl.Event.NativeStruct evt) =>
  81                 {
  82                     var obj = Efl.Eo.Globals.WrapperSupervisorPtrToManaged(data).Target;
  83                     if (obj != null)
  84                     {
  85                         EventArgs args = EventArgs.Empty;
  86                         try
  87                         {
  88                             value?.Invoke(obj, args);
  89                         }
  90                         catch (Exception e)
  91                         {
  92                             Eina.Log.Error(e.ToString());
  93                             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
  94                         }
  95                     }
  96                 };
  97
  98                 string key = "_ELM_PANES_EVENT_PRESS";
  99                 AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
 100             }
 101         }
 102
 103         remove
 104         {
 105             lock (eflBindingEventLock)
 106             {
 107                 string key = "_ELM_PANES_EVENT_PRESS";
 108                 RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
 109             }
 110         }
 111     }
 112     /// <summary>Method to raise event PressEvt.</summary>
 113     public void OnPressEvt(EventArgs e)
 114     {
 115         var key = "_ELM_PANES_EVENT_PRESS";
 116         IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
 117         if (desc == IntPtr.Zero)
 118         {
 119             Eina.Log.Error($"Failed to get native event {key}");
 120             return;
 121         }
 122
 123         Efl.Eo.Globals.efl_event_callback_call(this.NativeHandle, desc, IntPtr.Zero);
 124     }
 125     /// <summary>Called when panes are no longer pressed</summary>
 126     public event EventHandler UnpressEvt
 127     {
 128         add
 129         {
 130             lock (eflBindingEventLock)
 131             {
 132                 Efl.EventCb callerCb = (IntPtr data, ref Efl.Event.NativeStruct evt) =>
 133                 {
 134                     var obj = Efl.Eo.Globals.WrapperSupervisorPtrToManaged(data).Target;
 135                     if (obj != null)
 136                     {
 137                         EventArgs args = EventArgs.Empty;
 138                         try
 139                         {
 140                             value?.Invoke(obj, args);
 141                         }
 142                         catch (Exception e)
 143                         {
 144                             Eina.Log.Error(e.ToString());
 145                             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 146                         }
 147                     }
 148                 };
 149
 150                 string key = "_ELM_PANES_EVENT_UNPRESS";
 151                 AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
 152             }
 153         }
 154
 155         remove
 156         {
 157             lock (eflBindingEventLock)
 158             {
 159                 string key = "_ELM_PANES_EVENT_UNPRESS";
 160                 RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
 161             }
 162         }
 163     }
 164     /// <summary>Method to raise event UnpressEvt.</summary>
 165     public void OnUnpressEvt(EventArgs e)
 166     {
 167         var key = "_ELM_PANES_EVENT_UNPRESS";
 168         IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
 169         if (desc == IntPtr.Zero)
 170         {
 171             Eina.Log.Error($"Failed to get native event {key}");
 172             return;
 173         }
 174
 175         Efl.Eo.Globals.efl_event_callback_call(this.NativeHandle, desc, IntPtr.Zero);
 176     }
 177     /// <summary>Called when object is in sequence pressed and unpressed, by the primary button</summary>
 178     /// <value><see cref="Efl.Input.IClickableClickedEvt_Args"/></value>
 179     public event EventHandler<Efl.Input.IClickableClickedEvt_Args> ClickedEvt
 180     {
 181         add
 182         {
 183             lock (eflBindingEventLock)
 184             {
 185                 Efl.EventCb callerCb = (IntPtr data, ref Efl.Event.NativeStruct evt) =>
 186                 {
 187                     var obj = Efl.Eo.Globals.WrapperSupervisorPtrToManaged(data).Target;
 188                     if (obj != null)
 189                     {
 190                         Efl.Input.IClickableClickedEvt_Args args = new Efl.Input.IClickableClickedEvt_Args();
 191                         args.arg =  evt.Info;
 192                         try
 193                         {
 194                             value?.Invoke(obj, args);
 195                         }
 196                         catch (Exception e)
 197                         {
 198                             Eina.Log.Error(e.ToString());
 199                             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 200                         }
 201                     }
 202                 };
 203
 204                 string key = "_EFL_INPUT_EVENT_CLICKED";
 205                 AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
 206             }
 207         }
 208
 209         remove
 210         {
 211             lock (eflBindingEventLock)
 212             {
 213                 string key = "_EFL_INPUT_EVENT_CLICKED";
 214                 RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
 215             }
 216         }
 217     }
 218     /// <summary>Method to raise event ClickedEvt.</summary>
 219     public void OnClickedEvt(Efl.Input.IClickableClickedEvt_Args e)
 220     {
 221         var key = "_EFL_INPUT_EVENT_CLICKED";
 222         IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
 223         if (desc == IntPtr.Zero)
 224         {
 225             Eina.Log.Error($"Failed to get native event {key}");
 226             return;
 227         }
 228
 229         IntPtr info = Marshal.AllocHGlobal(Marshal.SizeOf(e.arg));
 230         try
 231         {
 232             Marshal.StructureToPtr(e.arg, info, false);
 233             Efl.Eo.Globals.efl_event_callback_call(this.NativeHandle, desc, info);
 234         }
 235         finally
 236         {
 237             Marshal.FreeHGlobal(info);
 238         }
 239     }
 240     /// <summary>Called when object is in sequence pressed and unpressed by any button. The button that triggered the event can be found in the event information.</summary>
 241     /// <value><see cref="Efl.Input.IClickableClickedAnyEvt_Args"/></value>
 242     public event EventHandler<Efl.Input.IClickableClickedAnyEvt_Args> ClickedAnyEvt
 243     {
 244         add
 245         {
 246             lock (eflBindingEventLock)
 247             {
 248                 Efl.EventCb callerCb = (IntPtr data, ref Efl.Event.NativeStruct evt) =>
 249                 {
 250                     var obj = Efl.Eo.Globals.WrapperSupervisorPtrToManaged(data).Target;
 251                     if (obj != null)
 252                     {
 253                         Efl.Input.IClickableClickedAnyEvt_Args args = new Efl.Input.IClickableClickedAnyEvt_Args();
 254                         args.arg =  evt.Info;
 255                         try
 256                         {
 257                             value?.Invoke(obj, args);
 258                         }
 259                         catch (Exception e)
 260                         {
 261                             Eina.Log.Error(e.ToString());
 262                             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 263                         }
 264                     }
 265                 };
 266
 267                 string key = "_EFL_INPUT_EVENT_CLICKED_ANY";
 268                 AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
 269             }
 270         }
 271
 272         remove
 273         {
 274             lock (eflBindingEventLock)
 275             {
 276                 string key = "_EFL_INPUT_EVENT_CLICKED_ANY";
 277                 RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
 278             }
 279         }
 280     }
 281     /// <summary>Method to raise event ClickedAnyEvt.</summary>
 282     public void OnClickedAnyEvt(Efl.Input.IClickableClickedAnyEvt_Args e)
 283     {
 284         var key = "_EFL_INPUT_EVENT_CLICKED_ANY";
 285         IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
 286         if (desc == IntPtr.Zero)
 287         {
 288             Eina.Log.Error($"Failed to get native event {key}");
 289             return;
 290         }
 291
 292         IntPtr info = Marshal.AllocHGlobal(Marshal.SizeOf(e.arg));
 293         try
 294         {
 295             Marshal.StructureToPtr(e.arg, info, false);
 296             Efl.Eo.Globals.efl_event_callback_call(this.NativeHandle, desc, info);
 297         }
 298         finally
 299         {
 300             Marshal.FreeHGlobal(info);
 301         }
 302     }
 303     /// <summary>Called when the object is pressed, event_info is the button that got pressed</summary>
 304     /// <value><see cref="Efl.Input.IClickablePressedEvt_Args"/></value>
 305     public event EventHandler<Efl.Input.IClickablePressedEvt_Args> PressedEvt
 306     {
 307         add
 308         {
 309             lock (eflBindingEventLock)
 310             {
 311                 Efl.EventCb callerCb = (IntPtr data, ref Efl.Event.NativeStruct evt) =>
 312                 {
 313                     var obj = Efl.Eo.Globals.WrapperSupervisorPtrToManaged(data).Target;
 314                     if (obj != null)
 315                     {
 316                         Efl.Input.IClickablePressedEvt_Args args = new Efl.Input.IClickablePressedEvt_Args();
 317                         args.arg = Marshal.ReadInt32(evt.Info);
 318                         try
 319                         {
 320                             value?.Invoke(obj, args);
 321                         }
 322                         catch (Exception e)
 323                         {
 324                             Eina.Log.Error(e.ToString());
 325                             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 326                         }
 327                     }
 328                 };
 329
 330                 string key = "_EFL_INPUT_EVENT_PRESSED";
 331                 AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
 332             }
 333         }
 334
 335         remove
 336         {
 337             lock (eflBindingEventLock)
 338             {
 339                 string key = "_EFL_INPUT_EVENT_PRESSED";
 340                 RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
 341             }
 342         }
 343     }
 344     /// <summary>Method to raise event PressedEvt.</summary>
 345     public void OnPressedEvt(Efl.Input.IClickablePressedEvt_Args e)
 346     {
 347         var key = "_EFL_INPUT_EVENT_PRESSED";
 348         IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
 349         if (desc == IntPtr.Zero)
 350         {
 351             Eina.Log.Error($"Failed to get native event {key}");
 352             return;
 353         }
 354
 355         IntPtr info = Eina.PrimitiveConversion.ManagedToPointerAlloc(e.arg);
 356         try
 357         {
 358             Efl.Eo.Globals.efl_event_callback_call(this.NativeHandle, desc, info);
 359         }
 360         finally
 361         {
 362             Marshal.FreeHGlobal(info);
 363         }
 364     }
 365     /// <summary>Called when the object is no longer pressed, event_info is the button that got pressed</summary>
 366     /// <value><see cref="Efl.Input.IClickableUnpressedEvt_Args"/></value>
 367     public event EventHandler<Efl.Input.IClickableUnpressedEvt_Args> UnpressedEvt
 368     {
 369         add
 370         {
 371             lock (eflBindingEventLock)
 372             {
 373                 Efl.EventCb callerCb = (IntPtr data, ref Efl.Event.NativeStruct evt) =>
 374                 {
 375                     var obj = Efl.Eo.Globals.WrapperSupervisorPtrToManaged(data).Target;
 376                     if (obj != null)
 377                     {
 378                         Efl.Input.IClickableUnpressedEvt_Args args = new Efl.Input.IClickableUnpressedEvt_Args();
 379                         args.arg = Marshal.ReadInt32(evt.Info);
 380                         try
 381                         {
 382                             value?.Invoke(obj, args);
 383                         }
 384                         catch (Exception e)
 385                         {
 386                             Eina.Log.Error(e.ToString());
 387                             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 388                         }
 389                     }
 390                 };
 391
 392                 string key = "_EFL_INPUT_EVENT_UNPRESSED";
 393                 AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
 394             }
 395         }
 396
 397         remove
 398         {
 399             lock (eflBindingEventLock)
 400             {
 401                 string key = "_EFL_INPUT_EVENT_UNPRESSED";
 402                 RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
 403             }
 404         }
 405     }
 406     /// <summary>Method to raise event UnpressedEvt.</summary>
 407     public void OnUnpressedEvt(Efl.Input.IClickableUnpressedEvt_Args e)
 408     {
 409         var key = "_EFL_INPUT_EVENT_UNPRESSED";
 410         IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
 411         if (desc == IntPtr.Zero)
 412         {
 413             Eina.Log.Error($"Failed to get native event {key}");
 414             return;
 415         }
 416
 417         IntPtr info = Eina.PrimitiveConversion.ManagedToPointerAlloc(e.arg);
 418         try
 419         {
 420             Efl.Eo.Globals.efl_event_callback_call(this.NativeHandle, desc, info);
 421         }
 422         finally
 423         {
 424             Marshal.FreeHGlobal(info);
 425         }
 426     }
 427     /// <summary>Called when the object receives a long press, event_info is the button that got pressed</summary>
 428     /// <value><see cref="Efl.Input.IClickableLongpressedEvt_Args"/></value>
 429     public event EventHandler<Efl.Input.IClickableLongpressedEvt_Args> LongpressedEvt
 430     {
 431         add
 432         {
 433             lock (eflBindingEventLock)
 434             {
 435                 Efl.EventCb callerCb = (IntPtr data, ref Efl.Event.NativeStruct evt) =>
 436                 {
 437                     var obj = Efl.Eo.Globals.WrapperSupervisorPtrToManaged(data).Target;
 438                     if (obj != null)
 439                     {
 440                         Efl.Input.IClickableLongpressedEvt_Args args = new Efl.Input.IClickableLongpressedEvt_Args();
 441                         args.arg = Marshal.ReadInt32(evt.Info);
 442                         try
 443                         {
 444                             value?.Invoke(obj, args);
 445                         }
 446                         catch (Exception e)
 447                         {
 448                             Eina.Log.Error(e.ToString());
 449                             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 450                         }
 451                     }
 452                 };
 453
 454                 string key = "_EFL_INPUT_EVENT_LONGPRESSED";
 455                 AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
 456             }
 457         }
 458
 459         remove
 460         {
 461             lock (eflBindingEventLock)
 462             {
 463                 string key = "_EFL_INPUT_EVENT_LONGPRESSED";
 464                 RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
 465             }
 466         }
 467     }
 468     /// <summary>Method to raise event LongpressedEvt.</summary>
 469     public void OnLongpressedEvt(Efl.Input.IClickableLongpressedEvt_Args e)
 470     {
 471         var key = "_EFL_INPUT_EVENT_LONGPRESSED";
 472         IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
 473         if (desc == IntPtr.Zero)
 474         {
 475             Eina.Log.Error($"Failed to get native event {key}");
 476             return;
 477         }
 478
 479         IntPtr info = Eina.PrimitiveConversion.ManagedToPointerAlloc(e.arg);
 480         try
 481         {
 482             Efl.Eo.Globals.efl_event_callback_call(this.NativeHandle, desc, info);
 483         }
 484         finally
 485         {
 486             Marshal.FreeHGlobal(info);
 487         }
 488     }
 489     /// <summary>The second half of the panes widget (right or bottom)</summary>
 490     public Efl.Ui.PanesPart SecondPart
 491     {
 492         get
 493         {
 494             return GetPart("second") as Efl.Ui.PanesPart;
 495         }
 496     }
 497     /// <summary>The first half of the panes widget (left or top)</summary>
 498     public Efl.Ui.PanesPart FirstPart
 499     {
 500         get
 501         {
 502             return GetPart("first") as Efl.Ui.PanesPart;
 503         }
 504     }
 505     /// <summary>Set the split ratio between panes widget first and second parts.
 506     /// By default it&apos;s homogeneous, i.e., both sides have the same size.
 507     ///
 508     /// If something different is required, it can be set with this function. For example, if the first content should be displayed over 75% of the panes size, <c>ratio</c> should be passed as 0.75. This way, second content will be resized to 25% of panes size.
 509     ///
 510     /// If displayed vertically, first content is displayed at top, and second content at bottom.
 511     ///
 512     /// Note: This ratio will change when user drags the panes bar.</summary>
 513     /// <returns>Value between 0.0 and 1.0 representing split ratio between panes first and second parts.</returns>
 514     virtual public double GetSplitRatio() {
 515          var _ret_var = Efl.Ui.Panes.NativeMethods.efl_ui_panes_split_ratio_get_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)));
 516         Eina.Error.RaiseIfUnhandledException();
 517         return _ret_var;
 518  }
 519     /// <summary>Set the split ratio between panes widget first and second parts.
 520     /// By default it&apos;s homogeneous, i.e., both sides have the same size.
 521     ///
 522     /// If something different is required, it can be set with this function. For example, if the first content should be displayed over 75% of the panes size, <c>ratio</c> should be passed as 0.75. This way, second content will be resized to 25% of panes size.
 523     ///
 524     /// If displayed vertically, first content is displayed at top, and second content at bottom.
 525     ///
 526     /// Note: This ratio will change when user drags the panes bar.</summary>
 527     /// <param name="ratio">Value between 0.0 and 1.0 representing split ratio between panes first and second parts.</param>
 528     virtual public void SetSplitRatio(double ratio) {
 529                                  Efl.Ui.Panes.NativeMethods.efl_ui_panes_split_ratio_set_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)),ratio);
 530         Eina.Error.RaiseIfUnhandledException();
 531                          }
 532     /// <summary>Set whether the left and right panes can be resized by user interaction.
 533     /// By default panes&apos; contents are resizable by user interaction.</summary>
 534     /// <returns>Use <c>true</c> to fix the left and right panes sizes and make them not to be resized by user interaction. Use <c>false</c> to make them resizable.</returns>
 535     virtual public bool GetFixed() {
 536          var _ret_var = Efl.Ui.Panes.NativeMethods.efl_ui_panes_fixed_get_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)));
 537         Eina.Error.RaiseIfUnhandledException();
 538         return _ret_var;
 539  }
 540     /// <summary>Set whether the left and right panes can be resized by user interaction.
 541     /// By default panes&apos; contents are resizable by user interaction.</summary>
 542     /// <param name="kw_fixed">Use <c>true</c> to fix the left and right panes sizes and make them not to be resized by user interaction. Use <c>false</c> to make them resizable.</param>
 543     virtual public void SetFixed(bool kw_fixed) {
 544                                  Efl.Ui.Panes.NativeMethods.efl_ui_panes_fixed_set_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)),kw_fixed);
 545         Eina.Error.RaiseIfUnhandledException();
 546                          }
 547     /// <summary>This returns true if the given object is currently in event emission</summary>
 548     virtual public bool GetInteraction() {
 549          var _ret_var = Efl.Input.IClickableConcrete.NativeMethods.efl_input_clickable_interaction_get_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)));
 550         Eina.Error.RaiseIfUnhandledException();
 551         return _ret_var;
 552  }
 553     /// <summary>Change internal states that a button got pressed.
 554     /// When the button is already pressed, this is silently ignored.</summary>
 555     /// <param name="button">The number of the button. FIXME ensure to have the right interval of possible input</param>
 556     virtual public void Press(uint button) {
 557                                  Efl.Input.IClickableConcrete.NativeMethods.efl_input_clickable_press_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)),button);
 558         Eina.Error.RaiseIfUnhandledException();
 559                          }
 560     /// <summary>Change internal states that a button got unpressed.
 561     /// When the button is not pressed, this is silently ignored.</summary>
 562     /// <param name="button">The number of the button. FIXME ensure to have the right interval of possible input</param>
 563     virtual public void Unpress(uint button) {
 564                                  Efl.Input.IClickableConcrete.NativeMethods.efl_input_clickable_unpress_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)),button);
 565         Eina.Error.RaiseIfUnhandledException();
 566                          }
 567     /// <summary>This aborts the internal state after a press call.
 568     /// This will stop the timer for longpress. And set the state of the clickable mixin back into the unpressed state.</summary>
 569     virtual public void ResetButtonState(uint button) {
 570                                  Efl.Input.IClickableConcrete.NativeMethods.efl_input_clickable_button_state_reset_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)),button);
 571         Eina.Error.RaiseIfUnhandledException();
 572                          }
 573     /// <summary>This aborts ongoing longpress event.
 574     /// That is, this will stop the timer for longpress.</summary>
 575     virtual public void LongpressAbort(uint button) {
 576                                  Efl.Input.IClickableConcrete.NativeMethods.efl_input_clickable_longpress_abort_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)),button);
 577         Eina.Error.RaiseIfUnhandledException();
 578                          }
 579     /// <summary>Control the direction of a given widget.
 580     /// Use this function to change how your widget is to be disposed: vertically or horizontally or inverted vertically or inverted horizontally.
 581     ///
 582     /// Mirroring as defined in <see cref="Efl.Ui.II18n"/> can invert the <c>horizontal</c> direction: it is <c>ltr</c> by default, but becomes <c>rtl</c> if the object is mirrored.</summary>
 583     /// <returns>Direction of the widget.</returns>
 584     virtual public Efl.Ui.LayoutOrientation GetOrientation() {
 585          var _ret_var = Efl.Ui.ILayoutOrientableConcrete.NativeMethods.efl_ui_layout_orientation_get_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)));
 586         Eina.Error.RaiseIfUnhandledException();
 587         return _ret_var;
 588  }
 589     /// <summary>Control the direction of a given widget.
 590     /// Use this function to change how your widget is to be disposed: vertically or horizontally or inverted vertically or inverted horizontally.
 591     ///
 592     /// Mirroring as defined in <see cref="Efl.Ui.II18n"/> can invert the <c>horizontal</c> direction: it is <c>ltr</c> by default, but becomes <c>rtl</c> if the object is mirrored.</summary>
 593     /// <param name="dir">Direction of the widget.</param>
 594     virtual public void SetOrientation(Efl.Ui.LayoutOrientation dir) {
 595                                  Efl.Ui.ILayoutOrientableConcrete.NativeMethods.efl_ui_layout_orientation_set_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)),dir);
 596         Eina.Error.RaiseIfUnhandledException();
 597                          }
 598     /// <summary>Set the split ratio between panes widget first and second parts.
 599     /// By default it&apos;s homogeneous, i.e., both sides have the same size.
 600     ///
 601     /// If something different is required, it can be set with this function. For example, if the first content should be displayed over 75% of the panes size, <c>ratio</c> should be passed as 0.75. This way, second content will be resized to 25% of panes size.
 602     ///
 603     /// If displayed vertically, first content is displayed at top, and second content at bottom.
 604     ///
 605     /// Note: This ratio will change when user drags the panes bar.</summary>
 606     /// <value>Value between 0.0 and 1.0 representing split ratio between panes first and second parts.</value>
 607     public double SplitRatio {
 608         get { return GetSplitRatio(); }
 609         set { SetSplitRatio(value); }
 610     }
 611     /// <summary>Set whether the left and right panes can be resized by user interaction.
 612     /// By default panes&apos; contents are resizable by user interaction.</summary>
 613     /// <value>Use <c>true</c> to fix the left and right panes sizes and make them not to be resized by user interaction. Use <c>false</c> to make them resizable.</value>
 614     public bool Fixed {
 615         get { return GetFixed(); }
 616         set { SetFixed(value); }
 617     }
 618     /// <summary>This returns true if the given object is currently in event emission</summary>
 619     public bool Interaction {
 620         get { return GetInteraction(); }
 621     }
 622     /// <summary>Control the direction of a given widget.
 623     /// Use this function to change how your widget is to be disposed: vertically or horizontally or inverted vertically or inverted horizontally.
 624     ///
 625     /// Mirroring as defined in <see cref="Efl.Ui.II18n"/> can invert the <c>horizontal</c> direction: it is <c>ltr</c> by default, but becomes <c>rtl</c> if the object is mirrored.</summary>
 626     /// <value>Direction of the widget.</value>
 627     public Efl.Ui.LayoutOrientation Orientation {
 628         get { return GetOrientation(); }
 629         set { SetOrientation(value); }
 630     }
 631     private static IntPtr GetEflClassStatic()
 632     {
 633         return Efl.Ui.Panes.efl_ui_panes_class_get();
 634     }
 635     /// <summary>Wrapper for native methods and virtual method delegates.
 636     /// For internal use by generated code only.</summary>
 637     public new class NativeMethods : Efl.Ui.LayoutBase.NativeMethods
 638     {
 639         private static Efl.Eo.NativeModule Module = new Efl.Eo.NativeModule(    efl.Libs.Elementary);
 640         /// <summary>Gets the list of Eo operations to override.</summary>
 641         /// <returns>The list of Eo operations to be overload.</returns>
 642         public override System.Collections.Generic.List<Efl_Op_Description> GetEoOps(System.Type type)
 643         {
 644             var descs = new System.Collections.Generic.List<Efl_Op_Description>();
 645             var methods = Efl.Eo.Globals.GetUserMethods(type);
 646
 647             if (efl_ui_panes_split_ratio_get_static_delegate == null)
 648             {
 649                 efl_ui_panes_split_ratio_get_static_delegate = new efl_ui_panes_split_ratio_get_delegate(split_ratio_get);
 650             }
 651
 652             if (methods.FirstOrDefault(m => m.Name == "GetSplitRatio") != null)
 653             {
 654                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_ui_panes_split_ratio_get"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_panes_split_ratio_get_static_delegate) });
 655             }
 656
 657             if (efl_ui_panes_split_ratio_set_static_delegate == null)
 658             {
 659                 efl_ui_panes_split_ratio_set_static_delegate = new efl_ui_panes_split_ratio_set_delegate(split_ratio_set);
 660             }
 661
 662             if (methods.FirstOrDefault(m => m.Name == "SetSplitRatio") != null)
 663             {
 664                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_ui_panes_split_ratio_set"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_panes_split_ratio_set_static_delegate) });
 665             }
 666
 667             if (efl_ui_panes_fixed_get_static_delegate == null)
 668             {
 669                 efl_ui_panes_fixed_get_static_delegate = new efl_ui_panes_fixed_get_delegate(fixed_get);
 670             }
 671
 672             if (methods.FirstOrDefault(m => m.Name == "GetFixed") != null)
 673             {
 674                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_ui_panes_fixed_get"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_panes_fixed_get_static_delegate) });
 675             }
 676
 677             if (efl_ui_panes_fixed_set_static_delegate == null)
 678             {
 679                 efl_ui_panes_fixed_set_static_delegate = new efl_ui_panes_fixed_set_delegate(fixed_set);
 680             }
 681
 682             if (methods.FirstOrDefault(m => m.Name == "SetFixed") != null)
 683             {
 684                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_ui_panes_fixed_set"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_panes_fixed_set_static_delegate) });
 685             }
 686
 687             if (efl_input_clickable_interaction_get_static_delegate == null)
 688             {
 689                 efl_input_clickable_interaction_get_static_delegate = new efl_input_clickable_interaction_get_delegate(interaction_get);
 690             }
 691
 692             if (methods.FirstOrDefault(m => m.Name == "GetInteraction") != null)
 693             {
 694                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_input_clickable_interaction_get"), func = Marshal.GetFunctionPointerForDelegate(efl_input_clickable_interaction_get_static_delegate) });
 695             }
 696
 697             if (efl_input_clickable_press_static_delegate == null)
 698             {
 699                 efl_input_clickable_press_static_delegate = new efl_input_clickable_press_delegate(press);
 700             }
 701
 702             if (methods.FirstOrDefault(m => m.Name == "Press") != null)
 703             {
 704                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_input_clickable_press"), func = Marshal.GetFunctionPointerForDelegate(efl_input_clickable_press_static_delegate) });
 705             }
 706
 707             if (efl_input_clickable_unpress_static_delegate == null)
 708             {
 709                 efl_input_clickable_unpress_static_delegate = new efl_input_clickable_unpress_delegate(unpress);
 710             }
 711
 712             if (methods.FirstOrDefault(m => m.Name == "Unpress") != null)
 713             {
 714                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_input_clickable_unpress"), func = Marshal.GetFunctionPointerForDelegate(efl_input_clickable_unpress_static_delegate) });
 715             }
 716
 717             if (efl_input_clickable_button_state_reset_static_delegate == null)
 718             {
 719                 efl_input_clickable_button_state_reset_static_delegate = new efl_input_clickable_button_state_reset_delegate(button_state_reset);
 720             }
 721
 722             if (methods.FirstOrDefault(m => m.Name == "ResetButtonState") != null)
 723             {
 724                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_input_clickable_button_state_reset"), func = Marshal.GetFunctionPointerForDelegate(efl_input_clickable_button_state_reset_static_delegate) });
 725             }
 726
 727             if (efl_input_clickable_longpress_abort_static_delegate == null)
 728             {
 729                 efl_input_clickable_longpress_abort_static_delegate = new efl_input_clickable_longpress_abort_delegate(longpress_abort);
 730             }
 731
 732             if (methods.FirstOrDefault(m => m.Name == "LongpressAbort") != null)
 733             {
 734                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_input_clickable_longpress_abort"), func = Marshal.GetFunctionPointerForDelegate(efl_input_clickable_longpress_abort_static_delegate) });
 735             }
 736
 737             if (efl_ui_layout_orientation_get_static_delegate == null)
 738             {
 739                 efl_ui_layout_orientation_get_static_delegate = new efl_ui_layout_orientation_get_delegate(orientation_get);
 740             }
 741
 742             if (methods.FirstOrDefault(m => m.Name == "GetOrientation") != null)
 743             {
 744                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_ui_layout_orientation_get"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_layout_orientation_get_static_delegate) });
 745             }
 746
 747             if (efl_ui_layout_orientation_set_static_delegate == null)
 748             {
 749                 efl_ui_layout_orientation_set_static_delegate = new efl_ui_layout_orientation_set_delegate(orientation_set);
 750             }
 751
 752             if (methods.FirstOrDefault(m => m.Name == "SetOrientation") != null)
 753             {
 754                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_ui_layout_orientation_set"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_layout_orientation_set_static_delegate) });
 755             }
 756
 757             descs.AddRange(base.GetEoOps(type));
 758             return descs;
 759         }
 760         /// <summary>Returns the Eo class for the native methods of this class.</summary>
 761         /// <returns>The native class pointer.</returns>
 762         public override IntPtr GetEflClass()
 763         {
 764             return Efl.Ui.Panes.efl_ui_panes_class_get();
 765         }
 766
 767         #pragma warning disable CA1707, CS1591, SA1300, SA1600
 768
 769
 770         private delegate double efl_ui_panes_split_ratio_get_delegate(System.IntPtr obj, System.IntPtr pd);
 771
 772
 773         public delegate double efl_ui_panes_split_ratio_get_api_delegate(System.IntPtr obj);
 774
 775         public static Efl.Eo.FunctionWrapper<efl_ui_panes_split_ratio_get_api_delegate> efl_ui_panes_split_ratio_get_ptr = new Efl.Eo.FunctionWrapper<efl_ui_panes_split_ratio_get_api_delegate>(Module, "efl_ui_panes_split_ratio_get");
 776
 777         private static double split_ratio_get(System.IntPtr obj, System.IntPtr pd)
 778         {
 779             Eina.Log.Debug("function efl_ui_panes_split_ratio_get was called");
 780             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 781             if (ws != null)
 782             {
 783             double _ret_var = default(double);
 784                 try
 785                 {
 786                     _ret_var = ((Panes)ws.Target).GetSplitRatio();
 787                 }
 788                 catch (Exception e)
 789                 {
 790                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 791                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 792                 }
 793
 794         return _ret_var;
 795
 796             }
 797             else
 798             {
 799                 return efl_ui_panes_split_ratio_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
 800             }
 801         }
 802
 803         private static efl_ui_panes_split_ratio_get_delegate efl_ui_panes_split_ratio_get_static_delegate;
 804
 805
 806         private delegate void efl_ui_panes_split_ratio_set_delegate(System.IntPtr obj, System.IntPtr pd,  double ratio);
 807
 808
 809         public delegate void efl_ui_panes_split_ratio_set_api_delegate(System.IntPtr obj,  double ratio);
 810
 811         public static Efl.Eo.FunctionWrapper<efl_ui_panes_split_ratio_set_api_delegate> efl_ui_panes_split_ratio_set_ptr = new Efl.Eo.FunctionWrapper<efl_ui_panes_split_ratio_set_api_delegate>(Module, "efl_ui_panes_split_ratio_set");
 812
 813         private static void split_ratio_set(System.IntPtr obj, System.IntPtr pd, double ratio)
 814         {
 815             Eina.Log.Debug("function efl_ui_panes_split_ratio_set was called");
 816             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 817             if (ws != null)
 818             {
 819
 820                 try
 821                 {
 822                     ((Panes)ws.Target).SetSplitRatio(ratio);
 823                 }
 824                 catch (Exception e)
 825                 {
 826                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 827                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 828                 }
 829
 830
 831             }
 832             else
 833             {
 834                 efl_ui_panes_split_ratio_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), ratio);
 835             }
 836         }
 837
 838         private static efl_ui_panes_split_ratio_set_delegate efl_ui_panes_split_ratio_set_static_delegate;
 839
 840         [return: MarshalAs(UnmanagedType.U1)]
 841         private delegate bool efl_ui_panes_fixed_get_delegate(System.IntPtr obj, System.IntPtr pd);
 842
 843         [return: MarshalAs(UnmanagedType.U1)]
 844         public delegate bool efl_ui_panes_fixed_get_api_delegate(System.IntPtr obj);
 845
 846         public static Efl.Eo.FunctionWrapper<efl_ui_panes_fixed_get_api_delegate> efl_ui_panes_fixed_get_ptr = new Efl.Eo.FunctionWrapper<efl_ui_panes_fixed_get_api_delegate>(Module, "efl_ui_panes_fixed_get");
 847
 848         private static bool fixed_get(System.IntPtr obj, System.IntPtr pd)
 849         {
 850             Eina.Log.Debug("function efl_ui_panes_fixed_get was called");
 851             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 852             if (ws != null)
 853             {
 854             bool _ret_var = default(bool);
 855                 try
 856                 {
 857                     _ret_var = ((Panes)ws.Target).GetFixed();
 858                 }
 859                 catch (Exception e)
 860                 {
 861                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 862                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 863                 }
 864
 865         return _ret_var;
 866
 867             }
 868             else
 869             {
 870                 return efl_ui_panes_fixed_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
 871             }
 872         }
 873
 874         private static efl_ui_panes_fixed_get_delegate efl_ui_panes_fixed_get_static_delegate;
 875
 876
 877         private delegate void efl_ui_panes_fixed_set_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.U1)] bool kw_fixed);
 878
 879
 880         public delegate void efl_ui_panes_fixed_set_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.U1)] bool kw_fixed);
 881
 882         public static Efl.Eo.FunctionWrapper<efl_ui_panes_fixed_set_api_delegate> efl_ui_panes_fixed_set_ptr = new Efl.Eo.FunctionWrapper<efl_ui_panes_fixed_set_api_delegate>(Module, "efl_ui_panes_fixed_set");
 883
 884         private static void fixed_set(System.IntPtr obj, System.IntPtr pd, bool kw_fixed)
 885         {
 886             Eina.Log.Debug("function efl_ui_panes_fixed_set was called");
 887             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 888             if (ws != null)
 889             {
 890
 891                 try
 892                 {
 893                     ((Panes)ws.Target).SetFixed(kw_fixed);
 894                 }
 895                 catch (Exception e)
 896                 {
 897                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 898                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 899                 }
 900
 901
 902             }
 903             else
 904             {
 905                 efl_ui_panes_fixed_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), kw_fixed);
 906             }
 907         }
 908
 909         private static efl_ui_panes_fixed_set_delegate efl_ui_panes_fixed_set_static_delegate;
 910
 911         [return: MarshalAs(UnmanagedType.U1)]
 912         private delegate bool efl_input_clickable_interaction_get_delegate(System.IntPtr obj, System.IntPtr pd);
 913
 914         [return: MarshalAs(UnmanagedType.U1)]
 915         public delegate bool efl_input_clickable_interaction_get_api_delegate(System.IntPtr obj);
 916
 917         public static Efl.Eo.FunctionWrapper<efl_input_clickable_interaction_get_api_delegate> efl_input_clickable_interaction_get_ptr = new Efl.Eo.FunctionWrapper<efl_input_clickable_interaction_get_api_delegate>(Module, "efl_input_clickable_interaction_get");
 918
 919         private static bool interaction_get(System.IntPtr obj, System.IntPtr pd)
 920         {
 921             Eina.Log.Debug("function efl_input_clickable_interaction_get was called");
 922             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 923             if (ws != null)
 924             {
 925             bool _ret_var = default(bool);
 926                 try
 927                 {
 928                     _ret_var = ((Panes)ws.Target).GetInteraction();
 929                 }
 930                 catch (Exception e)
 931                 {
 932                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 933                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 934                 }
 935
 936         return _ret_var;
 937
 938             }
 939             else
 940             {
 941                 return efl_input_clickable_interaction_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
 942             }
 943         }
 944
 945         private static efl_input_clickable_interaction_get_delegate efl_input_clickable_interaction_get_static_delegate;
 946
 947
 948         private delegate void efl_input_clickable_press_delegate(System.IntPtr obj, System.IntPtr pd,  uint button);
 949
 950
 951         public delegate void efl_input_clickable_press_api_delegate(System.IntPtr obj,  uint button);
 952
 953         public static Efl.Eo.FunctionWrapper<efl_input_clickable_press_api_delegate> efl_input_clickable_press_ptr = new Efl.Eo.FunctionWrapper<efl_input_clickable_press_api_delegate>(Module, "efl_input_clickable_press");
 954
 955         private static void press(System.IntPtr obj, System.IntPtr pd, uint button)
 956         {
 957             Eina.Log.Debug("function efl_input_clickable_press was called");
 958             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 959             if (ws != null)
 960             {
 961
 962                 try
 963                 {
 964                     ((Panes)ws.Target).Press(button);
 965                 }
 966                 catch (Exception e)
 967                 {
 968                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 969                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 970                 }
 971
 972
 973             }
 974             else
 975             {
 976                 efl_input_clickable_press_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), button);
 977             }
 978         }
 979
 980         private static efl_input_clickable_press_delegate efl_input_clickable_press_static_delegate;
 981
 982
 983         private delegate void efl_input_clickable_unpress_delegate(System.IntPtr obj, System.IntPtr pd,  uint button);
 984
 985
 986         public delegate void efl_input_clickable_unpress_api_delegate(System.IntPtr obj,  uint button);
 987
 988         public static Efl.Eo.FunctionWrapper<efl_input_clickable_unpress_api_delegate> efl_input_clickable_unpress_ptr = new Efl.Eo.FunctionWrapper<efl_input_clickable_unpress_api_delegate>(Module, "efl_input_clickable_unpress");
 989
 990         private static void unpress(System.IntPtr obj, System.IntPtr pd, uint button)
 991         {
 992             Eina.Log.Debug("function efl_input_clickable_unpress was called");
 993             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 994             if (ws != null)
 995             {
 996
 997                 try
 998                 {
 999                     ((Panes)ws.Target).Unpress(button);
1000                 }
1001                 catch (Exception e)
1002                 {
1003                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1004                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1005                 }
1006
1007
1008             }
1009             else
1010             {
1011                 efl_input_clickable_unpress_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), button);
1012             }
1013         }
1014
1015         private static efl_input_clickable_unpress_delegate efl_input_clickable_unpress_static_delegate;
1016
1017
1018         private delegate void efl_input_clickable_button_state_reset_delegate(System.IntPtr obj, System.IntPtr pd,  uint button);
1019
1020
1021         public delegate void efl_input_clickable_button_state_reset_api_delegate(System.IntPtr obj,  uint button);
1022
1023         public static Efl.Eo.FunctionWrapper<efl_input_clickable_button_state_reset_api_delegate> efl_input_clickable_button_state_reset_ptr = new Efl.Eo.FunctionWrapper<efl_input_clickable_button_state_reset_api_delegate>(Module, "efl_input_clickable_button_state_reset");
1024
1025         private static void button_state_reset(System.IntPtr obj, System.IntPtr pd, uint button)
1026         {
1027             Eina.Log.Debug("function efl_input_clickable_button_state_reset was called");
1028             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1029             if (ws != null)
1030             {
1031
1032                 try
1033                 {
1034                     ((Panes)ws.Target).ResetButtonState(button);
1035                 }
1036                 catch (Exception e)
1037                 {
1038                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1039                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1040                 }
1041
1042
1043             }
1044             else
1045             {
1046                 efl_input_clickable_button_state_reset_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), button);
1047             }
1048         }
1049
1050         private static efl_input_clickable_button_state_reset_delegate efl_input_clickable_button_state_reset_static_delegate;
1051
1052
1053         private delegate void efl_input_clickable_longpress_abort_delegate(System.IntPtr obj, System.IntPtr pd,  uint button);
1054
1055
1056         public delegate void efl_input_clickable_longpress_abort_api_delegate(System.IntPtr obj,  uint button);
1057
1058         public static Efl.Eo.FunctionWrapper<efl_input_clickable_longpress_abort_api_delegate> efl_input_clickable_longpress_abort_ptr = new Efl.Eo.FunctionWrapper<efl_input_clickable_longpress_abort_api_delegate>(Module, "efl_input_clickable_longpress_abort");
1059
1060         private static void longpress_abort(System.IntPtr obj, System.IntPtr pd, uint button)
1061         {
1062             Eina.Log.Debug("function efl_input_clickable_longpress_abort was called");
1063             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1064             if (ws != null)
1065             {
1066
1067                 try
1068                 {
1069                     ((Panes)ws.Target).LongpressAbort(button);
1070                 }
1071                 catch (Exception e)
1072                 {
1073                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1074                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1075                 }
1076
1077
1078             }
1079             else
1080             {
1081                 efl_input_clickable_longpress_abort_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), button);
1082             }
1083         }
1084
1085         private static efl_input_clickable_longpress_abort_delegate efl_input_clickable_longpress_abort_static_delegate;
1086
1087
1088         private delegate Efl.Ui.LayoutOrientation efl_ui_layout_orientation_get_delegate(System.IntPtr obj, System.IntPtr pd);
1089
1090
1091         public delegate Efl.Ui.LayoutOrientation efl_ui_layout_orientation_get_api_delegate(System.IntPtr obj);
1092
1093         public static Efl.Eo.FunctionWrapper<efl_ui_layout_orientation_get_api_delegate> efl_ui_layout_orientation_get_ptr = new Efl.Eo.FunctionWrapper<efl_ui_layout_orientation_get_api_delegate>(Module, "efl_ui_layout_orientation_get");
1094
1095         private static Efl.Ui.LayoutOrientation orientation_get(System.IntPtr obj, System.IntPtr pd)
1096         {
1097             Eina.Log.Debug("function efl_ui_layout_orientation_get was called");
1098             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1099             if (ws != null)
1100             {
1101             Efl.Ui.LayoutOrientation _ret_var = default(Efl.Ui.LayoutOrientation);
1102                 try
1103                 {
1104                     _ret_var = ((Panes)ws.Target).GetOrientation();
1105                 }
1106                 catch (Exception e)
1107                 {
1108                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1109                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1110                 }
1111
1112         return _ret_var;
1113
1114             }
1115             else
1116             {
1117                 return efl_ui_layout_orientation_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
1118             }
1119         }
1120
1121         private static efl_ui_layout_orientation_get_delegate efl_ui_layout_orientation_get_static_delegate;
1122
1123
1124         private delegate void efl_ui_layout_orientation_set_delegate(System.IntPtr obj, System.IntPtr pd,  Efl.Ui.LayoutOrientation dir);
1125
1126
1127         public delegate void efl_ui_layout_orientation_set_api_delegate(System.IntPtr obj,  Efl.Ui.LayoutOrientation dir);
1128
1129         public static Efl.Eo.FunctionWrapper<efl_ui_layout_orientation_set_api_delegate> efl_ui_layout_orientation_set_ptr = new Efl.Eo.FunctionWrapper<efl_ui_layout_orientation_set_api_delegate>(Module, "efl_ui_layout_orientation_set");
1130
1131         private static void orientation_set(System.IntPtr obj, System.IntPtr pd, Efl.Ui.LayoutOrientation dir)
1132         {
1133             Eina.Log.Debug("function efl_ui_layout_orientation_set was called");
1134             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1135             if (ws != null)
1136             {
1137
1138                 try
1139                 {
1140                     ((Panes)ws.Target).SetOrientation(dir);
1141                 }
1142                 catch (Exception e)
1143                 {
1144                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1145                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1146                 }
1147
1148
1149             }
1150             else
1151             {
1152                 efl_ui_layout_orientation_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), dir);
1153             }
1154         }
1155
1156         private static efl_ui_layout_orientation_set_delegate efl_ui_layout_orientation_set_static_delegate;
1157
1158         #pragma warning restore CA1707, CS1591, SA1300, SA1600
1159
1160 }
1161 }
1162 }
1163
1164 }
1165
1166 #if EFL_BETA
1167 #pragma warning disable CS1591
1168 public static class Efl_UiPanes_ExtensionMethods {
1169     public static Efl.BindableProperty<double> SplitRatio<T>(this Efl.Ui.ItemFactory<T> fac, Efl.Csharp.ExtensionTag<Efl.Ui.Panes, T>magic = null) where T : Efl.Ui.Panes {
1170         return new Efl.BindableProperty<double>("split_ratio", fac);
1171     }
1172
1173     public static Efl.BindableProperty<bool> Fixed<T>(this Efl.Ui.ItemFactory<T> fac, Efl.Csharp.ExtensionTag<Efl.Ui.Panes, T>magic = null) where T : Efl.Ui.Panes {
1174         return new Efl.BindableProperty<bool>("fixed", fac);
1175     }
1176
1177
1178     public static Efl.BindableProperty<Efl.Ui.LayoutOrientation> Orientation<T>(this Efl.Ui.ItemFactory<T> fac, Efl.Csharp.ExtensionTag<Efl.Ui.Panes, T>magic = null) where T : Efl.Ui.Panes {
1179         return new Efl.BindableProperty<Efl.Ui.LayoutOrientation>("orientation", fac);
1180     }
1181
1182         public static Efl.BindableFactoryPart<Efl.Ui.PanesPart> SecondPart<T>(this Efl.Ui.ItemFactory<T> fac, Efl.Csharp.ExtensionTag<Efl.Ui.Panes, T> x=null) where T : Efl.Ui.Panes
1183     {
1184         return new Efl.BindableFactoryPart<Efl.Ui.PanesPart>("second" ,fac);
1185     }
1186
1187         public static Efl.BindableFactoryPart<Efl.Ui.PanesPart> FirstPart<T>(this Efl.Ui.ItemFactory<T> fac, Efl.Csharp.ExtensionTag<Efl.Ui.Panes, T> x=null) where T : Efl.Ui.Panes
1188     {
1189         return new Efl.BindableFactoryPart<Efl.Ui.PanesPart>("first" ,fac);
1190     }
1191
1192 }
1193 #pragma warning restore CS1591
1194 #endif