internals/src/EflSharp/EflSharp/efl/efl_ui_frame.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>Frame widget
  13 /// The Frame widget allows for collapsing and expanding the content widget by clicking on the frame label. the label and content can be set using text_set and content_set api.</summary>
  14 [Efl.Ui.Frame.NativeMethods]
  15 [Efl.Eo.BindingEntity]
  16 public class Frame : Efl.Ui.LayoutBase, Efl.IContent, Efl.IText, Efl.ITextMarkup, Efl.Ui.IClickable
  17 {
  18     ///<summary>Pointer to the native class description.</summary>
  19     public override System.IntPtr NativeClass
  20     {
  21         get
  22         {
  23             if (((object)this).GetType() == typeof(Frame))
  24             {
  25                 return GetEflClassStatic();
  26             }
  27             else
  28             {
  29                 return Efl.Eo.ClassRegister.klassFromType[((object)this).GetType()];
  30             }
  31         }
  32     }
  33
  34     [System.Runtime.InteropServices.DllImport(efl.Libs.Elementary)] internal static extern System.IntPtr
  35         efl_ui_frame_class_get();
  36     /// <summary>Initializes a new instance of the <see cref="Frame"/> class.</summary>
  37     /// <param name="parent">Parent instance.</param>
  38     /// <param name="style">The widget style to use. See <see cref="Efl.Ui.Widget.SetStyle" /></param>
  39     public Frame(Efl.Object parent
  40             , System.String style = null) : base(efl_ui_frame_class_get(), parent)
  41     {
  42         if (Efl.Eo.Globals.ParamHelperCheck(style))
  43         {
  44             SetStyle(Efl.Eo.Globals.GetParamHelper(style));
  45         }
  46
  47         FinishInstantiation();
  48     }
  49
  50     /// <summary>Constructor to be used when objects are expected to be constructed from native code.</summary>
  51     /// <param name="ch">Tag struct storing the native handle of the object being constructed.</param>
  52     protected Frame(ConstructingHandle ch) : base(ch)
  53     {
  54     }
  55
  56     /// <summary>Initializes a new instance of the <see cref="Frame"/> class.
  57     /// Internal usage: Constructs an instance from a native pointer. This is used when interacting with C code and should not be used directly.</summary>
  58     /// <param name="wh">The native pointer to be wrapped.</param>
  59     protected Frame(Efl.Eo.Globals.WrappingHandle wh) : base(wh)
  60     {
  61     }
  62
  63     /// <summary>Initializes a new instance of the <see cref="Frame"/> class.
  64     /// Internal usage: Constructor to forward the wrapper initialization to the root class that interfaces with native code. Should not be used directly.</summary>
  65     /// <param name="baseKlass">The pointer to the base native Eo class.</param>
  66     /// <param name="parent">The Efl.Object parent of this instance.</param>
  67     protected Frame(IntPtr baseKlass, Efl.Object parent) : base(baseKlass, parent)
  68     {
  69     }
  70
  71     /// <summary>Sent after the content is set or unset using the current content object.
  72     /// (Since EFL 1.22)</summary>
  73     public event EventHandler<Efl.IContentContentChangedEvt_Args> ContentChangedEvt
  74     {
  75         add
  76         {
  77             lock (eflBindingEventLock)
  78             {
  79                 Efl.EventCb callerCb = (IntPtr data, ref Efl.Event.NativeStruct evt) =>
  80                 {
  81                     var obj = Efl.Eo.Globals.WrapperSupervisorPtrToManaged(data).Target;
  82                     if (obj != null)
  83                     {
  84                         Efl.IContentContentChangedEvt_Args args = new Efl.IContentContentChangedEvt_Args();
  85                         args.arg = (Efl.Eo.Globals.CreateWrapperFor(evt.Info) as Efl.Gfx.IEntityConcrete);
  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 = "_EFL_CONTENT_EVENT_CONTENT_CHANGED";
  99                 AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
 100             }
 101         }
 102
 103         remove
 104         {
 105             lock (eflBindingEventLock)
 106             {
 107                 string key = "_EFL_CONTENT_EVENT_CONTENT_CHANGED";
 108                 RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
 109             }
 110         }
 111     }
 112     ///<summary>Method to raise event ContentChangedEvt.</summary>
 113     public void OnContentChangedEvt(Efl.IContentContentChangedEvt_Args e)
 114     {
 115         var key = "_EFL_CONTENT_EVENT_CONTENT_CHANGED";
 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         IntPtr info = e.arg.NativeHandle;
 124         Efl.Eo.Globals.efl_event_callback_call(this.NativeHandle, desc, info);
 125     }
 126     /// <summary>Called when object is in sequence pressed and unpressed, by the primary button</summary>
 127     public event EventHandler<Efl.Ui.IClickableClickedEvt_Args> ClickedEvt
 128     {
 129         add
 130         {
 131             lock (eflBindingEventLock)
 132             {
 133                 Efl.EventCb callerCb = (IntPtr data, ref Efl.Event.NativeStruct evt) =>
 134                 {
 135                     var obj = Efl.Eo.Globals.WrapperSupervisorPtrToManaged(data).Target;
 136                     if (obj != null)
 137                     {
 138                         Efl.Ui.IClickableClickedEvt_Args args = new Efl.Ui.IClickableClickedEvt_Args();
 139                         args.arg =  evt.Info;
 140                         try
 141                         {
 142                             value?.Invoke(obj, args);
 143                         }
 144                         catch (Exception e)
 145                         {
 146                             Eina.Log.Error(e.ToString());
 147                             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 148                         }
 149                     }
 150                 };
 151
 152                 string key = "_EFL_UI_EVENT_CLICKED";
 153                 AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
 154             }
 155         }
 156
 157         remove
 158         {
 159             lock (eflBindingEventLock)
 160             {
 161                 string key = "_EFL_UI_EVENT_CLICKED";
 162                 RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
 163             }
 164         }
 165     }
 166     ///<summary>Method to raise event ClickedEvt.</summary>
 167     public void OnClickedEvt(Efl.Ui.IClickableClickedEvt_Args e)
 168     {
 169         var key = "_EFL_UI_EVENT_CLICKED";
 170         IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
 171         if (desc == IntPtr.Zero)
 172         {
 173             Eina.Log.Error($"Failed to get native event {key}");
 174             return;
 175         }
 176
 177         IntPtr info = Marshal.AllocHGlobal(Marshal.SizeOf(e.arg));
 178         try
 179         {
 180             Marshal.StructureToPtr(e.arg, info, false);
 181             Efl.Eo.Globals.efl_event_callback_call(this.NativeHandle, desc, info);
 182         }
 183         finally
 184         {
 185             Marshal.FreeHGlobal(info);
 186         }
 187     }
 188     /// <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>
 189     public event EventHandler<Efl.Ui.IClickableClickedAnyEvt_Args> ClickedAnyEvt
 190     {
 191         add
 192         {
 193             lock (eflBindingEventLock)
 194             {
 195                 Efl.EventCb callerCb = (IntPtr data, ref Efl.Event.NativeStruct evt) =>
 196                 {
 197                     var obj = Efl.Eo.Globals.WrapperSupervisorPtrToManaged(data).Target;
 198                     if (obj != null)
 199                     {
 200                         Efl.Ui.IClickableClickedAnyEvt_Args args = new Efl.Ui.IClickableClickedAnyEvt_Args();
 201                         args.arg =  evt.Info;
 202                         try
 203                         {
 204                             value?.Invoke(obj, args);
 205                         }
 206                         catch (Exception e)
 207                         {
 208                             Eina.Log.Error(e.ToString());
 209                             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 210                         }
 211                     }
 212                 };
 213
 214                 string key = "_EFL_UI_EVENT_CLICKED_ANY";
 215                 AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
 216             }
 217         }
 218
 219         remove
 220         {
 221             lock (eflBindingEventLock)
 222             {
 223                 string key = "_EFL_UI_EVENT_CLICKED_ANY";
 224                 RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
 225             }
 226         }
 227     }
 228     ///<summary>Method to raise event ClickedAnyEvt.</summary>
 229     public void OnClickedAnyEvt(Efl.Ui.IClickableClickedAnyEvt_Args e)
 230     {
 231         var key = "_EFL_UI_EVENT_CLICKED_ANY";
 232         IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
 233         if (desc == IntPtr.Zero)
 234         {
 235             Eina.Log.Error($"Failed to get native event {key}");
 236             return;
 237         }
 238
 239         IntPtr info = Marshal.AllocHGlobal(Marshal.SizeOf(e.arg));
 240         try
 241         {
 242             Marshal.StructureToPtr(e.arg, info, false);
 243             Efl.Eo.Globals.efl_event_callback_call(this.NativeHandle, desc, info);
 244         }
 245         finally
 246         {
 247             Marshal.FreeHGlobal(info);
 248         }
 249     }
 250     /// <summary>Called when the object is pressed, event_info is the button that got pressed</summary>
 251     public event EventHandler<Efl.Ui.IClickablePressedEvt_Args> PressedEvt
 252     {
 253         add
 254         {
 255             lock (eflBindingEventLock)
 256             {
 257                 Efl.EventCb callerCb = (IntPtr data, ref Efl.Event.NativeStruct evt) =>
 258                 {
 259                     var obj = Efl.Eo.Globals.WrapperSupervisorPtrToManaged(data).Target;
 260                     if (obj != null)
 261                     {
 262                         Efl.Ui.IClickablePressedEvt_Args args = new Efl.Ui.IClickablePressedEvt_Args();
 263                         args.arg = Marshal.ReadInt32(evt.Info);
 264                         try
 265                         {
 266                             value?.Invoke(obj, args);
 267                         }
 268                         catch (Exception e)
 269                         {
 270                             Eina.Log.Error(e.ToString());
 271                             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 272                         }
 273                     }
 274                 };
 275
 276                 string key = "_EFL_UI_EVENT_PRESSED";
 277                 AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
 278             }
 279         }
 280
 281         remove
 282         {
 283             lock (eflBindingEventLock)
 284             {
 285                 string key = "_EFL_UI_EVENT_PRESSED";
 286                 RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
 287             }
 288         }
 289     }
 290     ///<summary>Method to raise event PressedEvt.</summary>
 291     public void OnPressedEvt(Efl.Ui.IClickablePressedEvt_Args e)
 292     {
 293         var key = "_EFL_UI_EVENT_PRESSED";
 294         IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
 295         if (desc == IntPtr.Zero)
 296         {
 297             Eina.Log.Error($"Failed to get native event {key}");
 298             return;
 299         }
 300
 301         IntPtr info = Eina.PrimitiveConversion.ManagedToPointerAlloc(e.arg);
 302         try
 303         {
 304             Efl.Eo.Globals.efl_event_callback_call(this.NativeHandle, desc, info);
 305         }
 306         finally
 307         {
 308             Marshal.FreeHGlobal(info);
 309         }
 310     }
 311     /// <summary>Called when the object is no longer pressed, event_info is the button that got pressed</summary>
 312     public event EventHandler<Efl.Ui.IClickableUnpressedEvt_Args> UnpressedEvt
 313     {
 314         add
 315         {
 316             lock (eflBindingEventLock)
 317             {
 318                 Efl.EventCb callerCb = (IntPtr data, ref Efl.Event.NativeStruct evt) =>
 319                 {
 320                     var obj = Efl.Eo.Globals.WrapperSupervisorPtrToManaged(data).Target;
 321                     if (obj != null)
 322                     {
 323                         Efl.Ui.IClickableUnpressedEvt_Args args = new Efl.Ui.IClickableUnpressedEvt_Args();
 324                         args.arg = Marshal.ReadInt32(evt.Info);
 325                         try
 326                         {
 327                             value?.Invoke(obj, args);
 328                         }
 329                         catch (Exception e)
 330                         {
 331                             Eina.Log.Error(e.ToString());
 332                             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 333                         }
 334                     }
 335                 };
 336
 337                 string key = "_EFL_UI_EVENT_UNPRESSED";
 338                 AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
 339             }
 340         }
 341
 342         remove
 343         {
 344             lock (eflBindingEventLock)
 345             {
 346                 string key = "_EFL_UI_EVENT_UNPRESSED";
 347                 RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
 348             }
 349         }
 350     }
 351     ///<summary>Method to raise event UnpressedEvt.</summary>
 352     public void OnUnpressedEvt(Efl.Ui.IClickableUnpressedEvt_Args e)
 353     {
 354         var key = "_EFL_UI_EVENT_UNPRESSED";
 355         IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
 356         if (desc == IntPtr.Zero)
 357         {
 358             Eina.Log.Error($"Failed to get native event {key}");
 359             return;
 360         }
 361
 362         IntPtr info = Eina.PrimitiveConversion.ManagedToPointerAlloc(e.arg);
 363         try
 364         {
 365             Efl.Eo.Globals.efl_event_callback_call(this.NativeHandle, desc, info);
 366         }
 367         finally
 368         {
 369             Marshal.FreeHGlobal(info);
 370         }
 371     }
 372     /// <summary>Called when the object receives a long press, event_info is the button that got pressed</summary>
 373     public event EventHandler<Efl.Ui.IClickableLongpressedEvt_Args> LongpressedEvt
 374     {
 375         add
 376         {
 377             lock (eflBindingEventLock)
 378             {
 379                 Efl.EventCb callerCb = (IntPtr data, ref Efl.Event.NativeStruct evt) =>
 380                 {
 381                     var obj = Efl.Eo.Globals.WrapperSupervisorPtrToManaged(data).Target;
 382                     if (obj != null)
 383                     {
 384                         Efl.Ui.IClickableLongpressedEvt_Args args = new Efl.Ui.IClickableLongpressedEvt_Args();
 385                         args.arg = Marshal.ReadInt32(evt.Info);
 386                         try
 387                         {
 388                             value?.Invoke(obj, args);
 389                         }
 390                         catch (Exception e)
 391                         {
 392                             Eina.Log.Error(e.ToString());
 393                             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 394                         }
 395                     }
 396                 };
 397
 398                 string key = "_EFL_UI_EVENT_LONGPRESSED";
 399                 AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
 400             }
 401         }
 402
 403         remove
 404         {
 405             lock (eflBindingEventLock)
 406             {
 407                 string key = "_EFL_UI_EVENT_LONGPRESSED";
 408                 RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
 409             }
 410         }
 411     }
 412     ///<summary>Method to raise event LongpressedEvt.</summary>
 413     public void OnLongpressedEvt(Efl.Ui.IClickableLongpressedEvt_Args e)
 414     {
 415         var key = "_EFL_UI_EVENT_LONGPRESSED";
 416         IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
 417         if (desc == IntPtr.Zero)
 418         {
 419             Eina.Log.Error($"Failed to get native event {key}");
 420             return;
 421         }
 422
 423         IntPtr info = Eina.PrimitiveConversion.ManagedToPointerAlloc(e.arg);
 424         try
 425         {
 426             Efl.Eo.Globals.efl_event_callback_call(this.NativeHandle, desc, info);
 427         }
 428         finally
 429         {
 430             Marshal.FreeHGlobal(info);
 431         }
 432     }
 433     /// <summary>Determine the collapse state of a frame Use this to determine the collapse state of a frame.</summary>
 434     /// <returns><c>true</c> to collapse, <c>false</c> to expand.</returns>
 435     virtual public bool GetCollapse() {
 436          var _ret_var = Efl.Ui.Frame.NativeMethods.efl_ui_frame_collapse_get_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)));
 437         Eina.Error.RaiseIfUnhandledException();
 438         return _ret_var;
 439  }
 440     /// <summary>Manually collapse a frame without animations Use this to toggle the collapsed state of a frame, bypassing animations.</summary>
 441     /// <param name="collapse"><c>true</c> to collapse, <c>false</c> to expand.</param>
 442     virtual public void SetCollapse(bool collapse) {
 443                                  Efl.Ui.Frame.NativeMethods.efl_ui_frame_collapse_set_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)),collapse);
 444         Eina.Error.RaiseIfUnhandledException();
 445                          }
 446     /// <summary>Determine autocollapsing of a frame
 447     /// When this returns <c>true</c>, clicking a frame&apos;s label will collapse the frame vertically, shrinking it to the height of the label. By default, this is DISABLED.</summary>
 448     /// <returns>Whether to enable autocollapse.</returns>
 449     virtual public bool GetAutocollapse() {
 450          var _ret_var = Efl.Ui.Frame.NativeMethods.efl_ui_frame_autocollapse_get_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)));
 451         Eina.Error.RaiseIfUnhandledException();
 452         return _ret_var;
 453  }
 454     /// <summary>Toggle autocollapsing of a frame When <c>enable</c> is <c>true</c>, clicking a frame&apos;s label will collapse the frame vertically, shrinking it to the height of the label. By default, this is DISABLED.</summary>
 455     /// <param name="autocollapse">Whether to enable autocollapse.</param>
 456     virtual public void SetAutocollapse(bool autocollapse) {
 457                                  Efl.Ui.Frame.NativeMethods.efl_ui_frame_autocollapse_set_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)),autocollapse);
 458         Eina.Error.RaiseIfUnhandledException();
 459                          }
 460     /// <summary>Manually collapse a frame with animations Use this to toggle the collapsed state of a frame, triggering animations.</summary>
 461     /// <param name="collapse"><c>true</c> to collapse, <c>false</c> to expand.</param>
 462     virtual public void CollapseGo(bool collapse) {
 463                                  Efl.Ui.Frame.NativeMethods.efl_ui_frame_collapse_go_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)),collapse);
 464         Eina.Error.RaiseIfUnhandledException();
 465                          }
 466     /// <summary>Sub-object currently set as this object&apos;s single content.
 467     /// If it is set multiple times, previous sub-objects are removed first. Therefore, if an invalid <c>content</c> is set the object will become empty (it will have no sub-object).
 468     /// (Since EFL 1.22)</summary>
 469     /// <returns>The sub-object.</returns>
 470     virtual public Efl.Gfx.IEntity GetContent() {
 471          var _ret_var = Efl.IContentConcrete.NativeMethods.efl_content_get_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)));
 472         Eina.Error.RaiseIfUnhandledException();
 473         return _ret_var;
 474  }
 475     /// <summary>Sub-object currently set as this object&apos;s single content.
 476     /// If it is set multiple times, previous sub-objects are removed first. Therefore, if an invalid <c>content</c> is set the object will become empty (it will have no sub-object).
 477     /// (Since EFL 1.22)</summary>
 478     /// <param name="content">The sub-object.</param>
 479     /// <returns><c>true</c> if <c>content</c> was successfully swallowed.</returns>
 480     virtual public bool SetContent(Efl.Gfx.IEntity content) {
 481                                  var _ret_var = Efl.IContentConcrete.NativeMethods.efl_content_set_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)),content);
 482         Eina.Error.RaiseIfUnhandledException();
 483                         return _ret_var;
 484  }
 485     /// <summary>Remove the sub-object currently set as content of this object and return it. This object becomes empty.
 486     /// (Since EFL 1.22)</summary>
 487     /// <returns>Unswallowed object</returns>
 488     virtual public Efl.Gfx.IEntity UnsetContent() {
 489          var _ret_var = Efl.IContentConcrete.NativeMethods.efl_content_unset_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)));
 490         Eina.Error.RaiseIfUnhandledException();
 491         return _ret_var;
 492  }
 493     /// <summary>Retrieves the text string currently being displayed by the given text object.
 494     /// Do not free() the return value.
 495     ///
 496     /// See also <see cref="Efl.IText.GetText"/>.
 497     /// (Since EFL 1.22)</summary>
 498     /// <returns>Text string to display on it.</returns>
 499     virtual public System.String GetText() {
 500          var _ret_var = Efl.ITextConcrete.NativeMethods.efl_text_get_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)));
 501         Eina.Error.RaiseIfUnhandledException();
 502         return _ret_var;
 503  }
 504     /// <summary>Sets the text string to be displayed by the given text object.
 505     /// See also <see cref="Efl.IText.GetText"/>.
 506     /// (Since EFL 1.22)</summary>
 507     /// <param name="text">Text string to display on it.</param>
 508     virtual public void SetText(System.String text) {
 509                                  Efl.ITextConcrete.NativeMethods.efl_text_set_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)),text);
 510         Eina.Error.RaiseIfUnhandledException();
 511                          }
 512     /// <summary>Markup property</summary>
 513     /// <returns>The markup-text representation set to this text.</returns>
 514     virtual public System.String GetMarkup() {
 515          var _ret_var = Efl.ITextMarkupConcrete.NativeMethods.efl_text_markup_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>Markup property</summary>
 520     /// <param name="markup">The markup-text representation set to this text.</param>
 521     virtual public void SetMarkup(System.String markup) {
 522                                  Efl.ITextMarkupConcrete.NativeMethods.efl_text_markup_set_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)),markup);
 523         Eina.Error.RaiseIfUnhandledException();
 524                          }
 525     /// <summary>Change internal states that a button got pressed.
 526     /// When the button is already pressed, this is silently ignored.</summary>
 527     /// <param name="button">The number of the button. FIXME ensure to have the right interval of possible input</param>
 528     virtual public void Press(uint button) {
 529                                  Efl.Ui.IClickableConcrete.NativeMethods.efl_ui_clickable_press_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)),button);
 530         Eina.Error.RaiseIfUnhandledException();
 531                          }
 532     /// <summary>Change internal states that a button got unpressed.
 533     /// When the button is not pressed, this is silently ignored.</summary>
 534     /// <param name="button">The number of the button. FIXME ensure to have the right interval of possible input</param>
 535     virtual public void Unpress(uint button) {
 536                                  Efl.Ui.IClickableConcrete.NativeMethods.efl_ui_clickable_unpress_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)),button);
 537         Eina.Error.RaiseIfUnhandledException();
 538                          }
 539     /// <summary>This aborts the internal state after a press call.
 540     /// This will stop the timer for longpress. And set the state of the clickable mixin back into the unpressed state.</summary>
 541     virtual public void ResetButtonState(uint button) {
 542                                  Efl.Ui.IClickableConcrete.NativeMethods.efl_ui_clickable_button_state_reset_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)),button);
 543         Eina.Error.RaiseIfUnhandledException();
 544                          }
 545     /// <summary>Determine the collapse state of a frame Use this to determine the collapse state of a frame.</summary>
 546     /// <value><c>true</c> to collapse, <c>false</c> to expand.</value>
 547     public bool Collapse {
 548         get { return GetCollapse(); }
 549         set { SetCollapse(value); }
 550     }
 551     /// <summary>Determine autocollapsing of a frame
 552     /// When this returns <c>true</c>, clicking a frame&apos;s label will collapse the frame vertically, shrinking it to the height of the label. By default, this is DISABLED.</summary>
 553     /// <value>Whether to enable autocollapse.</value>
 554     public bool Autocollapse {
 555         get { return GetAutocollapse(); }
 556         set { SetAutocollapse(value); }
 557     }
 558     /// <summary>Sub-object currently set as this object&apos;s single content.
 559     /// If it is set multiple times, previous sub-objects are removed first. Therefore, if an invalid <c>content</c> is set the object will become empty (it will have no sub-object).
 560     /// (Since EFL 1.22)</summary>
 561     /// <value>The sub-object.</value>
 562     public Efl.Gfx.IEntity Content {
 563         get { return GetContent(); }
 564         set { SetContent(value); }
 565     }
 566     /// <summary>Markup property</summary>
 567     /// <value>The markup-text representation set to this text.</value>
 568     public System.String Markup {
 569         get { return GetMarkup(); }
 570         set { SetMarkup(value); }
 571     }
 572     private static IntPtr GetEflClassStatic()
 573     {
 574         return Efl.Ui.Frame.efl_ui_frame_class_get();
 575     }
 576     /// <summary>Wrapper for native methods and virtual method delegates.
 577     /// For internal use by generated code only.</summary>
 578     public new class NativeMethods : Efl.Ui.LayoutBase.NativeMethods
 579     {
 580         private static Efl.Eo.NativeModule Module = new Efl.Eo.NativeModule(    efl.Libs.Elementary);
 581         /// <summary>Gets the list of Eo operations to override.</summary>
 582         /// <returns>The list of Eo operations to be overload.</returns>
 583         public override System.Collections.Generic.List<Efl_Op_Description> GetEoOps(System.Type type)
 584         {
 585             var descs = new System.Collections.Generic.List<Efl_Op_Description>();
 586             var methods = Efl.Eo.Globals.GetUserMethods(type);
 587
 588             if (efl_ui_frame_collapse_get_static_delegate == null)
 589             {
 590                 efl_ui_frame_collapse_get_static_delegate = new efl_ui_frame_collapse_get_delegate(collapse_get);
 591             }
 592
 593             if (methods.FirstOrDefault(m => m.Name == "GetCollapse") != null)
 594             {
 595                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_ui_frame_collapse_get"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_frame_collapse_get_static_delegate) });
 596             }
 597
 598             if (efl_ui_frame_collapse_set_static_delegate == null)
 599             {
 600                 efl_ui_frame_collapse_set_static_delegate = new efl_ui_frame_collapse_set_delegate(collapse_set);
 601             }
 602
 603             if (methods.FirstOrDefault(m => m.Name == "SetCollapse") != null)
 604             {
 605                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_ui_frame_collapse_set"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_frame_collapse_set_static_delegate) });
 606             }
 607
 608             if (efl_ui_frame_autocollapse_get_static_delegate == null)
 609             {
 610                 efl_ui_frame_autocollapse_get_static_delegate = new efl_ui_frame_autocollapse_get_delegate(autocollapse_get);
 611             }
 612
 613             if (methods.FirstOrDefault(m => m.Name == "GetAutocollapse") != null)
 614             {
 615                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_ui_frame_autocollapse_get"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_frame_autocollapse_get_static_delegate) });
 616             }
 617
 618             if (efl_ui_frame_autocollapse_set_static_delegate == null)
 619             {
 620                 efl_ui_frame_autocollapse_set_static_delegate = new efl_ui_frame_autocollapse_set_delegate(autocollapse_set);
 621             }
 622
 623             if (methods.FirstOrDefault(m => m.Name == "SetAutocollapse") != null)
 624             {
 625                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_ui_frame_autocollapse_set"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_frame_autocollapse_set_static_delegate) });
 626             }
 627
 628             if (efl_ui_frame_collapse_go_static_delegate == null)
 629             {
 630                 efl_ui_frame_collapse_go_static_delegate = new efl_ui_frame_collapse_go_delegate(collapse_go);
 631             }
 632
 633             if (methods.FirstOrDefault(m => m.Name == "CollapseGo") != null)
 634             {
 635                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_ui_frame_collapse_go"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_frame_collapse_go_static_delegate) });
 636             }
 637
 638             if (efl_content_get_static_delegate == null)
 639             {
 640                 efl_content_get_static_delegate = new efl_content_get_delegate(content_get);
 641             }
 642
 643             if (methods.FirstOrDefault(m => m.Name == "GetContent") != null)
 644             {
 645                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_content_get"), func = Marshal.GetFunctionPointerForDelegate(efl_content_get_static_delegate) });
 646             }
 647
 648             if (efl_content_set_static_delegate == null)
 649             {
 650                 efl_content_set_static_delegate = new efl_content_set_delegate(content_set);
 651             }
 652
 653             if (methods.FirstOrDefault(m => m.Name == "SetContent") != null)
 654             {
 655                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_content_set"), func = Marshal.GetFunctionPointerForDelegate(efl_content_set_static_delegate) });
 656             }
 657
 658             if (efl_content_unset_static_delegate == null)
 659             {
 660                 efl_content_unset_static_delegate = new efl_content_unset_delegate(content_unset);
 661             }
 662
 663             if (methods.FirstOrDefault(m => m.Name == "UnsetContent") != null)
 664             {
 665                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_content_unset"), func = Marshal.GetFunctionPointerForDelegate(efl_content_unset_static_delegate) });
 666             }
 667
 668             if (efl_text_get_static_delegate == null)
 669             {
 670                 efl_text_get_static_delegate = new efl_text_get_delegate(text_get);
 671             }
 672
 673             if (methods.FirstOrDefault(m => m.Name == "GetText") != null)
 674             {
 675                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_text_get"), func = Marshal.GetFunctionPointerForDelegate(efl_text_get_static_delegate) });
 676             }
 677
 678             if (efl_text_set_static_delegate == null)
 679             {
 680                 efl_text_set_static_delegate = new efl_text_set_delegate(text_set);
 681             }
 682
 683             if (methods.FirstOrDefault(m => m.Name == "SetText") != null)
 684             {
 685                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_text_set"), func = Marshal.GetFunctionPointerForDelegate(efl_text_set_static_delegate) });
 686             }
 687
 688             if (efl_text_markup_get_static_delegate == null)
 689             {
 690                 efl_text_markup_get_static_delegate = new efl_text_markup_get_delegate(markup_get);
 691             }
 692
 693             if (methods.FirstOrDefault(m => m.Name == "GetMarkup") != null)
 694             {
 695                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_text_markup_get"), func = Marshal.GetFunctionPointerForDelegate(efl_text_markup_get_static_delegate) });
 696             }
 697
 698             if (efl_text_markup_set_static_delegate == null)
 699             {
 700                 efl_text_markup_set_static_delegate = new efl_text_markup_set_delegate(markup_set);
 701             }
 702
 703             if (methods.FirstOrDefault(m => m.Name == "SetMarkup") != null)
 704             {
 705                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_text_markup_set"), func = Marshal.GetFunctionPointerForDelegate(efl_text_markup_set_static_delegate) });
 706             }
 707
 708             if (efl_ui_clickable_press_static_delegate == null)
 709             {
 710                 efl_ui_clickable_press_static_delegate = new efl_ui_clickable_press_delegate(press);
 711             }
 712
 713             if (methods.FirstOrDefault(m => m.Name == "Press") != null)
 714             {
 715                 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) });
 716             }
 717
 718             if (efl_ui_clickable_unpress_static_delegate == null)
 719             {
 720                 efl_ui_clickable_unpress_static_delegate = new efl_ui_clickable_unpress_delegate(unpress);
 721             }
 722
 723             if (methods.FirstOrDefault(m => m.Name == "Unpress") != null)
 724             {
 725                 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) });
 726             }
 727
 728             if (efl_ui_clickable_button_state_reset_static_delegate == null)
 729             {
 730                 efl_ui_clickable_button_state_reset_static_delegate = new efl_ui_clickable_button_state_reset_delegate(button_state_reset);
 731             }
 732
 733             if (methods.FirstOrDefault(m => m.Name == "ResetButtonState") != null)
 734             {
 735                 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) });
 736             }
 737
 738             descs.AddRange(base.GetEoOps(type));
 739             return descs;
 740         }
 741         /// <summary>Returns the Eo class for the native methods of this class.</summary>
 742         /// <returns>The native class pointer.</returns>
 743         public override IntPtr GetEflClass()
 744         {
 745             return Efl.Ui.Frame.efl_ui_frame_class_get();
 746         }
 747
 748         #pragma warning disable CA1707, CS1591, SA1300, SA1600
 749
 750         [return: MarshalAs(UnmanagedType.U1)]
 751         private delegate bool efl_ui_frame_collapse_get_delegate(System.IntPtr obj, System.IntPtr pd);
 752
 753         [return: MarshalAs(UnmanagedType.U1)]
 754         public delegate bool efl_ui_frame_collapse_get_api_delegate(System.IntPtr obj);
 755
 756         public static Efl.Eo.FunctionWrapper<efl_ui_frame_collapse_get_api_delegate> efl_ui_frame_collapse_get_ptr = new Efl.Eo.FunctionWrapper<efl_ui_frame_collapse_get_api_delegate>(Module, "efl_ui_frame_collapse_get");
 757
 758         private static bool collapse_get(System.IntPtr obj, System.IntPtr pd)
 759         {
 760             Eina.Log.Debug("function efl_ui_frame_collapse_get was called");
 761             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 762             if (ws != null)
 763             {
 764             bool _ret_var = default(bool);
 765                 try
 766                 {
 767                     _ret_var = ((Frame)ws.Target).GetCollapse();
 768                 }
 769                 catch (Exception e)
 770                 {
 771                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 772                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 773                 }
 774
 775         return _ret_var;
 776
 777             }
 778             else
 779             {
 780                 return efl_ui_frame_collapse_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
 781             }
 782         }
 783
 784         private static efl_ui_frame_collapse_get_delegate efl_ui_frame_collapse_get_static_delegate;
 785
 786
 787         private delegate void efl_ui_frame_collapse_set_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.U1)] bool collapse);
 788
 789
 790         public delegate void efl_ui_frame_collapse_set_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.U1)] bool collapse);
 791
 792         public static Efl.Eo.FunctionWrapper<efl_ui_frame_collapse_set_api_delegate> efl_ui_frame_collapse_set_ptr = new Efl.Eo.FunctionWrapper<efl_ui_frame_collapse_set_api_delegate>(Module, "efl_ui_frame_collapse_set");
 793
 794         private static void collapse_set(System.IntPtr obj, System.IntPtr pd, bool collapse)
 795         {
 796             Eina.Log.Debug("function efl_ui_frame_collapse_set was called");
 797             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 798             if (ws != null)
 799             {
 800
 801                 try
 802                 {
 803                     ((Frame)ws.Target).SetCollapse(collapse);
 804                 }
 805                 catch (Exception e)
 806                 {
 807                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 808                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 809                 }
 810
 811
 812             }
 813             else
 814             {
 815                 efl_ui_frame_collapse_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), collapse);
 816             }
 817         }
 818
 819         private static efl_ui_frame_collapse_set_delegate efl_ui_frame_collapse_set_static_delegate;
 820
 821         [return: MarshalAs(UnmanagedType.U1)]
 822         private delegate bool efl_ui_frame_autocollapse_get_delegate(System.IntPtr obj, System.IntPtr pd);
 823
 824         [return: MarshalAs(UnmanagedType.U1)]
 825         public delegate bool efl_ui_frame_autocollapse_get_api_delegate(System.IntPtr obj);
 826
 827         public static Efl.Eo.FunctionWrapper<efl_ui_frame_autocollapse_get_api_delegate> efl_ui_frame_autocollapse_get_ptr = new Efl.Eo.FunctionWrapper<efl_ui_frame_autocollapse_get_api_delegate>(Module, "efl_ui_frame_autocollapse_get");
 828
 829         private static bool autocollapse_get(System.IntPtr obj, System.IntPtr pd)
 830         {
 831             Eina.Log.Debug("function efl_ui_frame_autocollapse_get was called");
 832             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 833             if (ws != null)
 834             {
 835             bool _ret_var = default(bool);
 836                 try
 837                 {
 838                     _ret_var = ((Frame)ws.Target).GetAutocollapse();
 839                 }
 840                 catch (Exception e)
 841                 {
 842                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 843                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 844                 }
 845
 846         return _ret_var;
 847
 848             }
 849             else
 850             {
 851                 return efl_ui_frame_autocollapse_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
 852             }
 853         }
 854
 855         private static efl_ui_frame_autocollapse_get_delegate efl_ui_frame_autocollapse_get_static_delegate;
 856
 857
 858         private delegate void efl_ui_frame_autocollapse_set_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.U1)] bool autocollapse);
 859
 860
 861         public delegate void efl_ui_frame_autocollapse_set_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.U1)] bool autocollapse);
 862
 863         public static Efl.Eo.FunctionWrapper<efl_ui_frame_autocollapse_set_api_delegate> efl_ui_frame_autocollapse_set_ptr = new Efl.Eo.FunctionWrapper<efl_ui_frame_autocollapse_set_api_delegate>(Module, "efl_ui_frame_autocollapse_set");
 864
 865         private static void autocollapse_set(System.IntPtr obj, System.IntPtr pd, bool autocollapse)
 866         {
 867             Eina.Log.Debug("function efl_ui_frame_autocollapse_set was called");
 868             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 869             if (ws != null)
 870             {
 871
 872                 try
 873                 {
 874                     ((Frame)ws.Target).SetAutocollapse(autocollapse);
 875                 }
 876                 catch (Exception e)
 877                 {
 878                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 879                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 880                 }
 881
 882
 883             }
 884             else
 885             {
 886                 efl_ui_frame_autocollapse_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), autocollapse);
 887             }
 888         }
 889
 890         private static efl_ui_frame_autocollapse_set_delegate efl_ui_frame_autocollapse_set_static_delegate;
 891
 892
 893         private delegate void efl_ui_frame_collapse_go_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.U1)] bool collapse);
 894
 895
 896         public delegate void efl_ui_frame_collapse_go_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.U1)] bool collapse);
 897
 898         public static Efl.Eo.FunctionWrapper<efl_ui_frame_collapse_go_api_delegate> efl_ui_frame_collapse_go_ptr = new Efl.Eo.FunctionWrapper<efl_ui_frame_collapse_go_api_delegate>(Module, "efl_ui_frame_collapse_go");
 899
 900         private static void collapse_go(System.IntPtr obj, System.IntPtr pd, bool collapse)
 901         {
 902             Eina.Log.Debug("function efl_ui_frame_collapse_go was called");
 903             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 904             if (ws != null)
 905             {
 906
 907                 try
 908                 {
 909                     ((Frame)ws.Target).CollapseGo(collapse);
 910                 }
 911                 catch (Exception e)
 912                 {
 913                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 914                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 915                 }
 916
 917
 918             }
 919             else
 920             {
 921                 efl_ui_frame_collapse_go_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), collapse);
 922             }
 923         }
 924
 925         private static efl_ui_frame_collapse_go_delegate efl_ui_frame_collapse_go_static_delegate;
 926
 927         [return:MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))]
 928         private delegate Efl.Gfx.IEntity efl_content_get_delegate(System.IntPtr obj, System.IntPtr pd);
 929
 930         [return:MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))]
 931         public delegate Efl.Gfx.IEntity efl_content_get_api_delegate(System.IntPtr obj);
 932
 933         public static Efl.Eo.FunctionWrapper<efl_content_get_api_delegate> efl_content_get_ptr = new Efl.Eo.FunctionWrapper<efl_content_get_api_delegate>(Module, "efl_content_get");
 934
 935         private static Efl.Gfx.IEntity content_get(System.IntPtr obj, System.IntPtr pd)
 936         {
 937             Eina.Log.Debug("function efl_content_get was called");
 938             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 939             if (ws != null)
 940             {
 941             Efl.Gfx.IEntity _ret_var = default(Efl.Gfx.IEntity);
 942                 try
 943                 {
 944                     _ret_var = ((Frame)ws.Target).GetContent();
 945                 }
 946                 catch (Exception e)
 947                 {
 948                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 949                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 950                 }
 951
 952         return _ret_var;
 953
 954             }
 955             else
 956             {
 957                 return efl_content_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
 958             }
 959         }
 960
 961         private static efl_content_get_delegate efl_content_get_static_delegate;
 962
 963         [return: MarshalAs(UnmanagedType.U1)]
 964         private delegate bool efl_content_set_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))] Efl.Gfx.IEntity content);
 965
 966         [return: MarshalAs(UnmanagedType.U1)]
 967         public delegate bool efl_content_set_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))] Efl.Gfx.IEntity content);
 968
 969         public static Efl.Eo.FunctionWrapper<efl_content_set_api_delegate> efl_content_set_ptr = new Efl.Eo.FunctionWrapper<efl_content_set_api_delegate>(Module, "efl_content_set");
 970
 971         private static bool content_set(System.IntPtr obj, System.IntPtr pd, Efl.Gfx.IEntity content)
 972         {
 973             Eina.Log.Debug("function efl_content_set was called");
 974             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 975             if (ws != null)
 976             {
 977                                     bool _ret_var = default(bool);
 978                 try
 979                 {
 980                     _ret_var = ((Frame)ws.Target).SetContent(content);
 981                 }
 982                 catch (Exception e)
 983                 {
 984                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 985                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 986                 }
 987
 988                         return _ret_var;
 989
 990             }
 991             else
 992             {
 993                 return efl_content_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), content);
 994             }
 995         }
 996
 997         private static efl_content_set_delegate efl_content_set_static_delegate;
 998
 999         [return:MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))]
1000         private delegate Efl.Gfx.IEntity efl_content_unset_delegate(System.IntPtr obj, System.IntPtr pd);
1001
1002         [return:MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))]
1003         public delegate Efl.Gfx.IEntity efl_content_unset_api_delegate(System.IntPtr obj);
1004
1005         public static Efl.Eo.FunctionWrapper<efl_content_unset_api_delegate> efl_content_unset_ptr = new Efl.Eo.FunctionWrapper<efl_content_unset_api_delegate>(Module, "efl_content_unset");
1006
1007         private static Efl.Gfx.IEntity content_unset(System.IntPtr obj, System.IntPtr pd)
1008         {
1009             Eina.Log.Debug("function efl_content_unset was called");
1010             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1011             if (ws != null)
1012             {
1013             Efl.Gfx.IEntity _ret_var = default(Efl.Gfx.IEntity);
1014                 try
1015                 {
1016                     _ret_var = ((Frame)ws.Target).UnsetContent();
1017                 }
1018                 catch (Exception e)
1019                 {
1020                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1021                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1022                 }
1023
1024         return _ret_var;
1025
1026             }
1027             else
1028             {
1029                 return efl_content_unset_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
1030             }
1031         }
1032
1033         private static efl_content_unset_delegate efl_content_unset_static_delegate;
1034
1035         [return: MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))]
1036         private delegate System.String efl_text_get_delegate(System.IntPtr obj, System.IntPtr pd);
1037
1038         [return: MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))]
1039         public delegate System.String efl_text_get_api_delegate(System.IntPtr obj);
1040
1041         public static Efl.Eo.FunctionWrapper<efl_text_get_api_delegate> efl_text_get_ptr = new Efl.Eo.FunctionWrapper<efl_text_get_api_delegate>(Module, "efl_text_get");
1042
1043         private static System.String text_get(System.IntPtr obj, System.IntPtr pd)
1044         {
1045             Eina.Log.Debug("function efl_text_get was called");
1046             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1047             if (ws != null)
1048             {
1049             System.String _ret_var = default(System.String);
1050                 try
1051                 {
1052                     _ret_var = ((Frame)ws.Target).GetText();
1053                 }
1054                 catch (Exception e)
1055                 {
1056                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1057                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1058                 }
1059
1060         return _ret_var;
1061
1062             }
1063             else
1064             {
1065                 return efl_text_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
1066             }
1067         }
1068
1069         private static efl_text_get_delegate efl_text_get_static_delegate;
1070
1071
1072         private delegate void efl_text_set_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))] System.String text);
1073
1074
1075         public delegate void efl_text_set_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))] System.String text);
1076
1077         public static Efl.Eo.FunctionWrapper<efl_text_set_api_delegate> efl_text_set_ptr = new Efl.Eo.FunctionWrapper<efl_text_set_api_delegate>(Module, "efl_text_set");
1078
1079         private static void text_set(System.IntPtr obj, System.IntPtr pd, System.String text)
1080         {
1081             Eina.Log.Debug("function efl_text_set was called");
1082             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1083             if (ws != null)
1084             {
1085
1086                 try
1087                 {
1088                     ((Frame)ws.Target).SetText(text);
1089                 }
1090                 catch (Exception e)
1091                 {
1092                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1093                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1094                 }
1095
1096
1097             }
1098             else
1099             {
1100                 efl_text_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), text);
1101             }
1102         }
1103
1104         private static efl_text_set_delegate efl_text_set_static_delegate;
1105
1106         [return: MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))]
1107         private delegate System.String efl_text_markup_get_delegate(System.IntPtr obj, System.IntPtr pd);
1108
1109         [return: MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))]
1110         public delegate System.String efl_text_markup_get_api_delegate(System.IntPtr obj);
1111
1112         public static Efl.Eo.FunctionWrapper<efl_text_markup_get_api_delegate> efl_text_markup_get_ptr = new Efl.Eo.FunctionWrapper<efl_text_markup_get_api_delegate>(Module, "efl_text_markup_get");
1113
1114         private static System.String markup_get(System.IntPtr obj, System.IntPtr pd)
1115         {
1116             Eina.Log.Debug("function efl_text_markup_get was called");
1117             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1118             if (ws != null)
1119             {
1120             System.String _ret_var = default(System.String);
1121                 try
1122                 {
1123                     _ret_var = ((Frame)ws.Target).GetMarkup();
1124                 }
1125                 catch (Exception e)
1126                 {
1127                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1128                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1129                 }
1130
1131         return _ret_var;
1132
1133             }
1134             else
1135             {
1136                 return efl_text_markup_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
1137             }
1138         }
1139
1140         private static efl_text_markup_get_delegate efl_text_markup_get_static_delegate;
1141
1142
1143         private delegate void efl_text_markup_set_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))] System.String markup);
1144
1145
1146         public delegate void efl_text_markup_set_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))] System.String markup);
1147
1148         public static Efl.Eo.FunctionWrapper<efl_text_markup_set_api_delegate> efl_text_markup_set_ptr = new Efl.Eo.FunctionWrapper<efl_text_markup_set_api_delegate>(Module, "efl_text_markup_set");
1149
1150         private static void markup_set(System.IntPtr obj, System.IntPtr pd, System.String markup)
1151         {
1152             Eina.Log.Debug("function efl_text_markup_set was called");
1153             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1154             if (ws != null)
1155             {
1156
1157                 try
1158                 {
1159                     ((Frame)ws.Target).SetMarkup(markup);
1160                 }
1161                 catch (Exception e)
1162                 {
1163                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1164                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1165                 }
1166
1167
1168             }
1169             else
1170             {
1171                 efl_text_markup_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), markup);
1172             }
1173         }
1174
1175         private static efl_text_markup_set_delegate efl_text_markup_set_static_delegate;
1176
1177
1178         private delegate void efl_ui_clickable_press_delegate(System.IntPtr obj, System.IntPtr pd,  uint button);
1179
1180
1181         public delegate void efl_ui_clickable_press_api_delegate(System.IntPtr obj,  uint button);
1182
1183         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");
1184
1185         private static void press(System.IntPtr obj, System.IntPtr pd, uint button)
1186         {
1187             Eina.Log.Debug("function efl_ui_clickable_press was called");
1188             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1189             if (ws != null)
1190             {
1191
1192                 try
1193                 {
1194                     ((Frame)ws.Target).Press(button);
1195                 }
1196                 catch (Exception e)
1197                 {
1198                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1199                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1200                 }
1201
1202
1203             }
1204             else
1205             {
1206                 efl_ui_clickable_press_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), button);
1207             }
1208         }
1209
1210         private static efl_ui_clickable_press_delegate efl_ui_clickable_press_static_delegate;
1211
1212
1213         private delegate void efl_ui_clickable_unpress_delegate(System.IntPtr obj, System.IntPtr pd,  uint button);
1214
1215
1216         public delegate void efl_ui_clickable_unpress_api_delegate(System.IntPtr obj,  uint button);
1217
1218         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");
1219
1220         private static void unpress(System.IntPtr obj, System.IntPtr pd, uint button)
1221         {
1222             Eina.Log.Debug("function efl_ui_clickable_unpress was called");
1223             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1224             if (ws != null)
1225             {
1226
1227                 try
1228                 {
1229                     ((Frame)ws.Target).Unpress(button);
1230                 }
1231                 catch (Exception e)
1232                 {
1233                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1234                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1235                 }
1236
1237
1238             }
1239             else
1240             {
1241                 efl_ui_clickable_unpress_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), button);
1242             }
1243         }
1244
1245         private static efl_ui_clickable_unpress_delegate efl_ui_clickable_unpress_static_delegate;
1246
1247
1248         private delegate void efl_ui_clickable_button_state_reset_delegate(System.IntPtr obj, System.IntPtr pd,  uint button);
1249
1250
1251         public delegate void efl_ui_clickable_button_state_reset_api_delegate(System.IntPtr obj,  uint button);
1252
1253         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");
1254
1255         private static void button_state_reset(System.IntPtr obj, System.IntPtr pd, uint button)
1256         {
1257             Eina.Log.Debug("function efl_ui_clickable_button_state_reset was called");
1258             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1259             if (ws != null)
1260             {
1261
1262                 try
1263                 {
1264                     ((Frame)ws.Target).ResetButtonState(button);
1265                 }
1266                 catch (Exception e)
1267                 {
1268                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1269                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1270                 }
1271
1272
1273             }
1274             else
1275             {
1276                 efl_ui_clickable_button_state_reset_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), button);
1277             }
1278         }
1279
1280         private static efl_ui_clickable_button_state_reset_delegate efl_ui_clickable_button_state_reset_static_delegate;
1281
1282         #pragma warning restore CA1707, CS1591, SA1300, SA1600
1283
1284 }
1285 }
1286 }
1287
1288 }
1289