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