internals/src/EflSharp/EflSharp/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.ComponentModel;
   7 namespace Efl { namespace Ui {
   8 /// <summary>Frame widget
   9 /// 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>
  10 [FrameNativeInherit]
  11 public class Frame : Efl.Ui.LayoutBase, Efl.Eo.IWrapper,Efl.Content,Efl.Text,Efl.TextMarkup,Efl.Ui.Clickable
  12 {
  13    public new static System.IntPtr klass = System.IntPtr.Zero;
  14    public new static Efl.Ui.FrameNativeInherit nativeInherit = new Efl.Ui.FrameNativeInherit();
  15    ///<summary>Pointer to the native class description.</summary>
  16    public override System.IntPtr NativeClass {
  17       get {
  18          if (((object)this).GetType() == typeof (Frame))
  19             return Efl.Ui.FrameNativeInherit.GetEflClassStatic();
  20          else
  21             return Efl.Eo.ClassRegister.klassFromType[((object)this).GetType()];
  22       }
  23    }
  24    [System.Runtime.InteropServices.DllImport(efl.Libs.Elementary)] internal static extern System.IntPtr
  25       efl_ui_frame_class_get();
  26    ///<summary>Creates a new instance.</summary>
  27    ///<param name="parent">Parent instance.</param>
  28    ///<param name="style">The widget style to use. See <see cref="Efl.Ui.Widget.SetStyle"/></param>
  29    public Frame(Efl.Object parent
  30          ,  System.String style = null) :
  31       base(efl_ui_frame_class_get(), typeof(Frame), parent)
  32    {
  33       if (Efl.Eo.Globals.ParamHelperCheck(style))
  34          SetStyle(Efl.Eo.Globals.GetParamHelper(style));
  35       FinishInstantiation();
  36    }
  37    ///<summary>Internal usage: Constructs an instance from a native pointer. This is used when interacting with C code and should not be used directly.</summary>
  38    public Frame(System.IntPtr raw) : base(raw)
  39    {
  40             register_event_proxies();
  41    }
  42    ///<summary>Internal usage: Constructor to forward the wrapper initialization to the root class that interfaces with native code. Should not be used directly.</summary>
  43    protected Frame(IntPtr base_klass, System.Type managed_type, Efl.Object parent) : base(base_klass, managed_type, parent) {}
  44    ///<summary>Casts obj into an instance of this type.</summary>
  45    public new static Frame static_cast(Efl.Object obj)
  46    {
  47       if (obj == null)
  48          throw new System.ArgumentNullException("obj");
  49       return new Frame(obj.NativeHandle);
  50    }
  51    ///<summary>Verifies if the given object is equal to this one.</summary>
  52    public override bool Equals(object obj)
  53    {
  54       var other = obj as Efl.Object;
  55       if (other == null)
  56          return false;
  57       return this.NativeHandle == other.NativeHandle;
  58    }
  59    ///<summary>Gets the hash code for this object based on the native pointer it points to.</summary>
  60    public override int GetHashCode()
  61    {
  62       return this.NativeHandle.ToInt32();
  63    }
  64    ///<summary>Turns the native pointer into a string representation.</summary>
  65    public override String ToString()
  66    {
  67       return $"{this.GetType().Name}@[{this.NativeHandle.ToInt32():x}]";
  68    }
  69 private static object ContentChangedEvtKey = new object();
  70    /// <summary>Sent after the content is set or unset using the current content object.</summary>
  71    public event EventHandler<Efl.ContentContentChangedEvt_Args> ContentChangedEvt
  72    {
  73       add {
  74          lock (eventLock) {
  75             string key = "_EFL_CONTENT_EVENT_CONTENT_CHANGED";
  76             if (add_cpp_event_handler(efl.Libs.Efl, key, this.evt_ContentChangedEvt_delegate)) {
  77                eventHandlers.AddHandler(ContentChangedEvtKey , value);
  78             } else
  79                Eina.Log.Error($"Error adding proxy for event {key}");
  80          }
  81       }
  82       remove {
  83          lock (eventLock) {
  84             string key = "_EFL_CONTENT_EVENT_CONTENT_CHANGED";
  85             if (remove_cpp_event_handler(key, this.evt_ContentChangedEvt_delegate)) {
  86                eventHandlers.RemoveHandler(ContentChangedEvtKey , value);
  87             } else
  88                Eina.Log.Error($"Error removing proxy for event {key}");
  89          }
  90       }
  91    }
  92    ///<summary>Method to raise event ContentChangedEvt.</summary>
  93    public void On_ContentChangedEvt(Efl.ContentContentChangedEvt_Args e)
  94    {
  95       EventHandler<Efl.ContentContentChangedEvt_Args> evt;
  96       lock (eventLock) {
  97       evt = (EventHandler<Efl.ContentContentChangedEvt_Args>)eventHandlers[ContentChangedEvtKey];
  98       }
  99       evt?.Invoke(this, e);
 100    }
 101    Efl.EventCb evt_ContentChangedEvt_delegate;
 102    private void on_ContentChangedEvt_NativeCallback(System.IntPtr data, ref Efl.Event_StructInternal evt)
 103    {
 104       Efl.ContentContentChangedEvt_Args args = new Efl.ContentContentChangedEvt_Args();
 105       args.arg = new Efl.Gfx.EntityConcrete(evt.Info);
 106       try {
 107          On_ContentChangedEvt(args);
 108       } catch (Exception e) {
 109          Eina.Log.Error(e.ToString());
 110          Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 111       }
 112    }
 113
 114 private static object ClickedEvtKey = new object();
 115    /// <summary>Called when object is clicked</summary>
 116    public event EventHandler ClickedEvt
 117    {
 118       add {
 119          lock (eventLock) {
 120             string key = "_EFL_UI_EVENT_CLICKED";
 121             if (add_cpp_event_handler(efl.Libs.Efl, key, this.evt_ClickedEvt_delegate)) {
 122                eventHandlers.AddHandler(ClickedEvtKey , value);
 123             } else
 124                Eina.Log.Error($"Error adding proxy for event {key}");
 125          }
 126       }
 127       remove {
 128          lock (eventLock) {
 129             string key = "_EFL_UI_EVENT_CLICKED";
 130             if (remove_cpp_event_handler(key, this.evt_ClickedEvt_delegate)) {
 131                eventHandlers.RemoveHandler(ClickedEvtKey , value);
 132             } else
 133                Eina.Log.Error($"Error removing proxy for event {key}");
 134          }
 135       }
 136    }
 137    ///<summary>Method to raise event ClickedEvt.</summary>
 138    public void On_ClickedEvt(EventArgs e)
 139    {
 140       EventHandler evt;
 141       lock (eventLock) {
 142       evt = (EventHandler)eventHandlers[ClickedEvtKey];
 143       }
 144       evt?.Invoke(this, e);
 145    }
 146    Efl.EventCb evt_ClickedEvt_delegate;
 147    private void on_ClickedEvt_NativeCallback(System.IntPtr data, ref Efl.Event_StructInternal evt)
 148    {
 149       EventArgs args = EventArgs.Empty;
 150       try {
 151          On_ClickedEvt(args);
 152       } catch (Exception e) {
 153          Eina.Log.Error(e.ToString());
 154          Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 155       }
 156    }
 157
 158 private static object ClickedDoubleEvtKey = new object();
 159    /// <summary>Called when object receives a double click</summary>
 160    public event EventHandler ClickedDoubleEvt
 161    {
 162       add {
 163          lock (eventLock) {
 164             string key = "_EFL_UI_EVENT_CLICKED_DOUBLE";
 165             if (add_cpp_event_handler(efl.Libs.Efl, key, this.evt_ClickedDoubleEvt_delegate)) {
 166                eventHandlers.AddHandler(ClickedDoubleEvtKey , value);
 167             } else
 168                Eina.Log.Error($"Error adding proxy for event {key}");
 169          }
 170       }
 171       remove {
 172          lock (eventLock) {
 173             string key = "_EFL_UI_EVENT_CLICKED_DOUBLE";
 174             if (remove_cpp_event_handler(key, this.evt_ClickedDoubleEvt_delegate)) {
 175                eventHandlers.RemoveHandler(ClickedDoubleEvtKey , value);
 176             } else
 177                Eina.Log.Error($"Error removing proxy for event {key}");
 178          }
 179       }
 180    }
 181    ///<summary>Method to raise event ClickedDoubleEvt.</summary>
 182    public void On_ClickedDoubleEvt(EventArgs e)
 183    {
 184       EventHandler evt;
 185       lock (eventLock) {
 186       evt = (EventHandler)eventHandlers[ClickedDoubleEvtKey];
 187       }
 188       evt?.Invoke(this, e);
 189    }
 190    Efl.EventCb evt_ClickedDoubleEvt_delegate;
 191    private void on_ClickedDoubleEvt_NativeCallback(System.IntPtr data, ref Efl.Event_StructInternal evt)
 192    {
 193       EventArgs args = EventArgs.Empty;
 194       try {
 195          On_ClickedDoubleEvt(args);
 196       } catch (Exception e) {
 197          Eina.Log.Error(e.ToString());
 198          Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 199       }
 200    }
 201
 202 private static object ClickedTripleEvtKey = new object();
 203    /// <summary>Called when object receives a triple click</summary>
 204    public event EventHandler ClickedTripleEvt
 205    {
 206       add {
 207          lock (eventLock) {
 208             string key = "_EFL_UI_EVENT_CLICKED_TRIPLE";
 209             if (add_cpp_event_handler(efl.Libs.Efl, key, this.evt_ClickedTripleEvt_delegate)) {
 210                eventHandlers.AddHandler(ClickedTripleEvtKey , value);
 211             } else
 212                Eina.Log.Error($"Error adding proxy for event {key}");
 213          }
 214       }
 215       remove {
 216          lock (eventLock) {
 217             string key = "_EFL_UI_EVENT_CLICKED_TRIPLE";
 218             if (remove_cpp_event_handler(key, this.evt_ClickedTripleEvt_delegate)) {
 219                eventHandlers.RemoveHandler(ClickedTripleEvtKey , value);
 220             } else
 221                Eina.Log.Error($"Error removing proxy for event {key}");
 222          }
 223       }
 224    }
 225    ///<summary>Method to raise event ClickedTripleEvt.</summary>
 226    public void On_ClickedTripleEvt(EventArgs e)
 227    {
 228       EventHandler evt;
 229       lock (eventLock) {
 230       evt = (EventHandler)eventHandlers[ClickedTripleEvtKey];
 231       }
 232       evt?.Invoke(this, e);
 233    }
 234    Efl.EventCb evt_ClickedTripleEvt_delegate;
 235    private void on_ClickedTripleEvt_NativeCallback(System.IntPtr data, ref Efl.Event_StructInternal evt)
 236    {
 237       EventArgs args = EventArgs.Empty;
 238       try {
 239          On_ClickedTripleEvt(args);
 240       } catch (Exception e) {
 241          Eina.Log.Error(e.ToString());
 242          Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 243       }
 244    }
 245
 246 private static object ClickedRightEvtKey = new object();
 247    /// <summary>Called when object receives a right click</summary>
 248    public event EventHandler<Efl.Ui.ClickableClickedRightEvt_Args> ClickedRightEvt
 249    {
 250       add {
 251          lock (eventLock) {
 252             string key = "_EFL_UI_EVENT_CLICKED_RIGHT";
 253             if (add_cpp_event_handler(efl.Libs.Efl, key, this.evt_ClickedRightEvt_delegate)) {
 254                eventHandlers.AddHandler(ClickedRightEvtKey , value);
 255             } else
 256                Eina.Log.Error($"Error adding proxy for event {key}");
 257          }
 258       }
 259       remove {
 260          lock (eventLock) {
 261             string key = "_EFL_UI_EVENT_CLICKED_RIGHT";
 262             if (remove_cpp_event_handler(key, this.evt_ClickedRightEvt_delegate)) {
 263                eventHandlers.RemoveHandler(ClickedRightEvtKey , value);
 264             } else
 265                Eina.Log.Error($"Error removing proxy for event {key}");
 266          }
 267       }
 268    }
 269    ///<summary>Method to raise event ClickedRightEvt.</summary>
 270    public void On_ClickedRightEvt(Efl.Ui.ClickableClickedRightEvt_Args e)
 271    {
 272       EventHandler<Efl.Ui.ClickableClickedRightEvt_Args> evt;
 273       lock (eventLock) {
 274       evt = (EventHandler<Efl.Ui.ClickableClickedRightEvt_Args>)eventHandlers[ClickedRightEvtKey];
 275       }
 276       evt?.Invoke(this, e);
 277    }
 278    Efl.EventCb evt_ClickedRightEvt_delegate;
 279    private void on_ClickedRightEvt_NativeCallback(System.IntPtr data, ref Efl.Event_StructInternal evt)
 280    {
 281       Efl.Ui.ClickableClickedRightEvt_Args args = new Efl.Ui.ClickableClickedRightEvt_Args();
 282       args.arg = new Efl.Object(evt.Info);
 283       try {
 284          On_ClickedRightEvt(args);
 285       } catch (Exception e) {
 286          Eina.Log.Error(e.ToString());
 287          Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 288       }
 289    }
 290
 291 private static object PressedEvtKey = new object();
 292    /// <summary>Called when the object is pressed</summary>
 293    public event EventHandler<Efl.Ui.ClickablePressedEvt_Args> PressedEvt
 294    {
 295       add {
 296          lock (eventLock) {
 297             string key = "_EFL_UI_EVENT_PRESSED";
 298             if (add_cpp_event_handler(efl.Libs.Efl, key, this.evt_PressedEvt_delegate)) {
 299                eventHandlers.AddHandler(PressedEvtKey , value);
 300             } else
 301                Eina.Log.Error($"Error adding proxy for event {key}");
 302          }
 303       }
 304       remove {
 305          lock (eventLock) {
 306             string key = "_EFL_UI_EVENT_PRESSED";
 307             if (remove_cpp_event_handler(key, this.evt_PressedEvt_delegate)) {
 308                eventHandlers.RemoveHandler(PressedEvtKey , value);
 309             } else
 310                Eina.Log.Error($"Error removing proxy for event {key}");
 311          }
 312       }
 313    }
 314    ///<summary>Method to raise event PressedEvt.</summary>
 315    public void On_PressedEvt(Efl.Ui.ClickablePressedEvt_Args e)
 316    {
 317       EventHandler<Efl.Ui.ClickablePressedEvt_Args> evt;
 318       lock (eventLock) {
 319       evt = (EventHandler<Efl.Ui.ClickablePressedEvt_Args>)eventHandlers[PressedEvtKey];
 320       }
 321       evt?.Invoke(this, e);
 322    }
 323    Efl.EventCb evt_PressedEvt_delegate;
 324    private void on_PressedEvt_NativeCallback(System.IntPtr data, ref Efl.Event_StructInternal evt)
 325    {
 326       Efl.Ui.ClickablePressedEvt_Args args = new Efl.Ui.ClickablePressedEvt_Args();
 327       args.arg = new Efl.Object(evt.Info);
 328       try {
 329          On_PressedEvt(args);
 330       } catch (Exception e) {
 331          Eina.Log.Error(e.ToString());
 332          Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 333       }
 334    }
 335
 336 private static object UnpressedEvtKey = new object();
 337    /// <summary>Called when the object is no longer pressed</summary>
 338    public event EventHandler<Efl.Ui.ClickableUnpressedEvt_Args> UnpressedEvt
 339    {
 340       add {
 341          lock (eventLock) {
 342             string key = "_EFL_UI_EVENT_UNPRESSED";
 343             if (add_cpp_event_handler(efl.Libs.Efl, key, this.evt_UnpressedEvt_delegate)) {
 344                eventHandlers.AddHandler(UnpressedEvtKey , value);
 345             } else
 346                Eina.Log.Error($"Error adding proxy for event {key}");
 347          }
 348       }
 349       remove {
 350          lock (eventLock) {
 351             string key = "_EFL_UI_EVENT_UNPRESSED";
 352             if (remove_cpp_event_handler(key, this.evt_UnpressedEvt_delegate)) {
 353                eventHandlers.RemoveHandler(UnpressedEvtKey , value);
 354             } else
 355                Eina.Log.Error($"Error removing proxy for event {key}");
 356          }
 357       }
 358    }
 359    ///<summary>Method to raise event UnpressedEvt.</summary>
 360    public void On_UnpressedEvt(Efl.Ui.ClickableUnpressedEvt_Args e)
 361    {
 362       EventHandler<Efl.Ui.ClickableUnpressedEvt_Args> evt;
 363       lock (eventLock) {
 364       evt = (EventHandler<Efl.Ui.ClickableUnpressedEvt_Args>)eventHandlers[UnpressedEvtKey];
 365       }
 366       evt?.Invoke(this, e);
 367    }
 368    Efl.EventCb evt_UnpressedEvt_delegate;
 369    private void on_UnpressedEvt_NativeCallback(System.IntPtr data, ref Efl.Event_StructInternal evt)
 370    {
 371       Efl.Ui.ClickableUnpressedEvt_Args args = new Efl.Ui.ClickableUnpressedEvt_Args();
 372       args.arg = new Efl.Object(evt.Info);
 373       try {
 374          On_UnpressedEvt(args);
 375       } catch (Exception e) {
 376          Eina.Log.Error(e.ToString());
 377          Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 378       }
 379    }
 380
 381 private static object LongpressedEvtKey = new object();
 382    /// <summary>Called when the object receives a long press</summary>
 383    public event EventHandler<Efl.Ui.ClickableLongpressedEvt_Args> LongpressedEvt
 384    {
 385       add {
 386          lock (eventLock) {
 387             string key = "_EFL_UI_EVENT_LONGPRESSED";
 388             if (add_cpp_event_handler(efl.Libs.Efl, key, this.evt_LongpressedEvt_delegate)) {
 389                eventHandlers.AddHandler(LongpressedEvtKey , value);
 390             } else
 391                Eina.Log.Error($"Error adding proxy for event {key}");
 392          }
 393       }
 394       remove {
 395          lock (eventLock) {
 396             string key = "_EFL_UI_EVENT_LONGPRESSED";
 397             if (remove_cpp_event_handler(key, this.evt_LongpressedEvt_delegate)) {
 398                eventHandlers.RemoveHandler(LongpressedEvtKey , value);
 399             } else
 400                Eina.Log.Error($"Error removing proxy for event {key}");
 401          }
 402       }
 403    }
 404    ///<summary>Method to raise event LongpressedEvt.</summary>
 405    public void On_LongpressedEvt(Efl.Ui.ClickableLongpressedEvt_Args e)
 406    {
 407       EventHandler<Efl.Ui.ClickableLongpressedEvt_Args> evt;
 408       lock (eventLock) {
 409       evt = (EventHandler<Efl.Ui.ClickableLongpressedEvt_Args>)eventHandlers[LongpressedEvtKey];
 410       }
 411       evt?.Invoke(this, e);
 412    }
 413    Efl.EventCb evt_LongpressedEvt_delegate;
 414    private void on_LongpressedEvt_NativeCallback(System.IntPtr data, ref Efl.Event_StructInternal evt)
 415    {
 416       Efl.Ui.ClickableLongpressedEvt_Args args = new Efl.Ui.ClickableLongpressedEvt_Args();
 417       args.arg = new Efl.Object(evt.Info);
 418       try {
 419          On_LongpressedEvt(args);
 420       } catch (Exception e) {
 421          Eina.Log.Error(e.ToString());
 422          Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 423       }
 424    }
 425
 426 private static object RepeatedEvtKey = new object();
 427    /// <summary>Called when the object receives repeated presses/clicks</summary>
 428    public event EventHandler RepeatedEvt
 429    {
 430       add {
 431          lock (eventLock) {
 432             string key = "_EFL_UI_EVENT_REPEATED";
 433             if (add_cpp_event_handler(efl.Libs.Efl, key, this.evt_RepeatedEvt_delegate)) {
 434                eventHandlers.AddHandler(RepeatedEvtKey , value);
 435             } else
 436                Eina.Log.Error($"Error adding proxy for event {key}");
 437          }
 438       }
 439       remove {
 440          lock (eventLock) {
 441             string key = "_EFL_UI_EVENT_REPEATED";
 442             if (remove_cpp_event_handler(key, this.evt_RepeatedEvt_delegate)) {
 443                eventHandlers.RemoveHandler(RepeatedEvtKey , value);
 444             } else
 445                Eina.Log.Error($"Error removing proxy for event {key}");
 446          }
 447       }
 448    }
 449    ///<summary>Method to raise event RepeatedEvt.</summary>
 450    public void On_RepeatedEvt(EventArgs e)
 451    {
 452       EventHandler evt;
 453       lock (eventLock) {
 454       evt = (EventHandler)eventHandlers[RepeatedEvtKey];
 455       }
 456       evt?.Invoke(this, e);
 457    }
 458    Efl.EventCb evt_RepeatedEvt_delegate;
 459    private void on_RepeatedEvt_NativeCallback(System.IntPtr data, ref Efl.Event_StructInternal evt)
 460    {
 461       EventArgs args = EventArgs.Empty;
 462       try {
 463          On_RepeatedEvt(args);
 464       } catch (Exception e) {
 465          Eina.Log.Error(e.ToString());
 466          Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 467       }
 468    }
 469
 470    protected override void register_event_proxies()
 471    {
 472       base.register_event_proxies();
 473       evt_ContentChangedEvt_delegate = new Efl.EventCb(on_ContentChangedEvt_NativeCallback);
 474       evt_ClickedEvt_delegate = new Efl.EventCb(on_ClickedEvt_NativeCallback);
 475       evt_ClickedDoubleEvt_delegate = new Efl.EventCb(on_ClickedDoubleEvt_NativeCallback);
 476       evt_ClickedTripleEvt_delegate = new Efl.EventCb(on_ClickedTripleEvt_NativeCallback);
 477       evt_ClickedRightEvt_delegate = new Efl.EventCb(on_ClickedRightEvt_NativeCallback);
 478       evt_PressedEvt_delegate = new Efl.EventCb(on_PressedEvt_NativeCallback);
 479       evt_UnpressedEvt_delegate = new Efl.EventCb(on_UnpressedEvt_NativeCallback);
 480       evt_LongpressedEvt_delegate = new Efl.EventCb(on_LongpressedEvt_NativeCallback);
 481       evt_RepeatedEvt_delegate = new Efl.EventCb(on_RepeatedEvt_NativeCallback);
 482    }
 483    /// <summary>Determine the collapse state of a frame Use this to determine the collapse state of a frame.</summary>
 484    /// <returns><c>true</c> to collapse, <c>false</c> to expand.</returns>
 485    virtual public bool GetCollapse() {
 486        var _ret_var = Efl.Ui.FrameNativeInherit.efl_ui_frame_collapse_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 487       Eina.Error.RaiseIfUnhandledException();
 488       return _ret_var;
 489  }
 490    /// <summary>Manually collapse a frame without animations Use this to toggle the collapsed state of a frame, bypassing animations.</summary>
 491    /// <param name="collapse"><c>true</c> to collapse, <c>false</c> to expand.</param>
 492    /// <returns></returns>
 493    virtual public  void SetCollapse( bool collapse) {
 494                          Efl.Ui.FrameNativeInherit.efl_ui_frame_collapse_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), collapse);
 495       Eina.Error.RaiseIfUnhandledException();
 496                    }
 497    /// <summary>Determine autocollapsing of a frame
 498    /// 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>
 499    /// <returns>Whether to enable autocollapse.</returns>
 500    virtual public bool GetAutocollapse() {
 501        var _ret_var = Efl.Ui.FrameNativeInherit.efl_ui_frame_autocollapse_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>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>
 506    /// <param name="autocollapse">Whether to enable autocollapse.</param>
 507    /// <returns></returns>
 508    virtual public  void SetAutocollapse( bool autocollapse) {
 509                          Efl.Ui.FrameNativeInherit.efl_ui_frame_autocollapse_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), autocollapse);
 510       Eina.Error.RaiseIfUnhandledException();
 511                    }
 512    /// <summary>Manually collapse a frame with animations Use this to toggle the collapsed state of a frame, triggering animations.</summary>
 513    /// <param name="collapse"><c>true</c> to collapse, <c>false</c> to expand.</param>
 514    /// <returns></returns>
 515    virtual public  void CollapseGo( bool collapse) {
 516                          Efl.Ui.FrameNativeInherit.efl_ui_frame_collapse_go_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), collapse);
 517       Eina.Error.RaiseIfUnhandledException();
 518                    }
 519    /// <summary>Swallowed sub-object contained in this object.</summary>
 520    /// <returns>The object to swallow.</returns>
 521    virtual public Efl.Gfx.Entity GetContent() {
 522        var _ret_var = Efl.ContentNativeInherit.efl_content_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>Swallowed sub-object contained in this object.</summary>
 527    /// <param name="content">The object to swallow.</param>
 528    /// <returns><c>true</c> on success, <c>false</c> otherwise</returns>
 529    virtual public bool SetContent( Efl.Gfx.Entity content) {
 530                          var _ret_var = Efl.ContentNativeInherit.efl_content_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), content);
 531       Eina.Error.RaiseIfUnhandledException();
 532                   return _ret_var;
 533  }
 534    /// <summary>Unswallow the object in the current container and return it.</summary>
 535    /// <returns>Unswallowed object</returns>
 536    virtual public Efl.Gfx.Entity UnsetContent() {
 537        var _ret_var = Efl.ContentNativeInherit.efl_content_unset_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 538       Eina.Error.RaiseIfUnhandledException();
 539       return _ret_var;
 540  }
 541    /// <summary>Retrieves the text string currently being displayed by the given text object.
 542    /// Do not free() the return value.
 543    ///
 544    /// See also <see cref="Efl.Text.GetText"/>.</summary>
 545    /// <returns>Text string to display on it.</returns>
 546    virtual public  System.String GetText() {
 547        var _ret_var = Efl.TextNativeInherit.efl_text_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 548       Eina.Error.RaiseIfUnhandledException();
 549       return _ret_var;
 550  }
 551    /// <summary>Sets the text string to be displayed by the given text object.
 552    /// See also <see cref="Efl.Text.GetText"/>.</summary>
 553    /// <param name="text">Text string to display on it.</param>
 554    /// <returns></returns>
 555    virtual public  void SetText(  System.String text) {
 556                          Efl.TextNativeInherit.efl_text_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), text);
 557       Eina.Error.RaiseIfUnhandledException();
 558                    }
 559    /// <summary>Markup property
 560    /// 1.21</summary>
 561    /// <returns>The markup-text representation set to this text.
 562    /// 1.21</returns>
 563    virtual public  System.String GetMarkup() {
 564        var _ret_var = Efl.TextMarkupNativeInherit.efl_text_markup_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 565       Eina.Error.RaiseIfUnhandledException();
 566       return _ret_var;
 567  }
 568    /// <summary>Markup property
 569    /// 1.21</summary>
 570    /// <param name="markup">The markup-text representation set to this text.
 571    /// 1.21</param>
 572    /// <returns></returns>
 573    virtual public  void SetMarkup(  System.String markup) {
 574                          Efl.TextMarkupNativeInherit.efl_text_markup_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), markup);
 575       Eina.Error.RaiseIfUnhandledException();
 576                    }
 577    /// <summary>Determine the collapse state of a frame Use this to determine the collapse state of a frame.</summary>
 578 /// <value><c>true</c> to collapse, <c>false</c> to expand.</value>
 579    public bool Collapse {
 580       get { return GetCollapse(); }
 581       set { SetCollapse( value); }
 582    }
 583    /// <summary>Determine autocollapsing of a frame
 584 /// 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>
 585 /// <value>Whether to enable autocollapse.</value>
 586    public bool Autocollapse {
 587       get { return GetAutocollapse(); }
 588       set { SetAutocollapse( value); }
 589    }
 590    /// <summary>Swallowed sub-object contained in this object.</summary>
 591 /// <value>The object to swallow.</value>
 592    public Efl.Gfx.Entity Content {
 593       get { return GetContent(); }
 594       set { SetContent( value); }
 595    }
 596    /// <summary>Markup property
 597 /// 1.21</summary>
 598 /// <value>The markup-text representation set to this text.
 599 /// 1.21</value>
 600    public  System.String Markup {
 601       get { return GetMarkup(); }
 602       set { SetMarkup( value); }
 603    }
 604    private static new  IntPtr GetEflClassStatic()
 605    {
 606       return Efl.Ui.Frame.efl_ui_frame_class_get();
 607    }
 608 }
 609 public class FrameNativeInherit : Efl.Ui.LayoutBaseNativeInherit{
 610    public new  static Efl.Eo.NativeModule _Module = new Efl.Eo.NativeModule(efl.Libs.Elementary);
 611    public override System.Collections.Generic.List<Efl_Op_Description> GetEoOps(System.Type type)
 612    {
 613       var descs = new System.Collections.Generic.List<Efl_Op_Description>();
 614       if (efl_ui_frame_collapse_get_static_delegate == null)
 615       efl_ui_frame_collapse_get_static_delegate = new efl_ui_frame_collapse_get_delegate(collapse_get);
 616       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)});
 617       if (efl_ui_frame_collapse_set_static_delegate == null)
 618       efl_ui_frame_collapse_set_static_delegate = new efl_ui_frame_collapse_set_delegate(collapse_set);
 619       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)});
 620       if (efl_ui_frame_autocollapse_get_static_delegate == null)
 621       efl_ui_frame_autocollapse_get_static_delegate = new efl_ui_frame_autocollapse_get_delegate(autocollapse_get);
 622       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)});
 623       if (efl_ui_frame_autocollapse_set_static_delegate == null)
 624       efl_ui_frame_autocollapse_set_static_delegate = new efl_ui_frame_autocollapse_set_delegate(autocollapse_set);
 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       if (efl_ui_frame_collapse_go_static_delegate == null)
 627       efl_ui_frame_collapse_go_static_delegate = new efl_ui_frame_collapse_go_delegate(collapse_go);
 628       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)});
 629       if (efl_content_get_static_delegate == null)
 630       efl_content_get_static_delegate = new efl_content_get_delegate(content_get);
 631       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)});
 632       if (efl_content_set_static_delegate == null)
 633       efl_content_set_static_delegate = new efl_content_set_delegate(content_set);
 634       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)});
 635       if (efl_content_unset_static_delegate == null)
 636       efl_content_unset_static_delegate = new efl_content_unset_delegate(content_unset);
 637       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)});
 638       if (efl_text_get_static_delegate == null)
 639       efl_text_get_static_delegate = new efl_text_get_delegate(text_get);
 640       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)});
 641       if (efl_text_set_static_delegate == null)
 642       efl_text_set_static_delegate = new efl_text_set_delegate(text_set);
 643       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)});
 644       if (efl_text_markup_get_static_delegate == null)
 645       efl_text_markup_get_static_delegate = new efl_text_markup_get_delegate(markup_get);
 646       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)});
 647       if (efl_text_markup_set_static_delegate == null)
 648       efl_text_markup_set_static_delegate = new efl_text_markup_set_delegate(markup_set);
 649       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)});
 650       descs.AddRange(base.GetEoOps(type));
 651       return descs;
 652    }
 653    public override IntPtr GetEflClass()
 654    {
 655       return Efl.Ui.Frame.efl_ui_frame_class_get();
 656    }
 657    public static new  IntPtr GetEflClassStatic()
 658    {
 659       return Efl.Ui.Frame.efl_ui_frame_class_get();
 660    }
 661
 662
 663     [return: MarshalAs(UnmanagedType.U1)] private delegate bool efl_ui_frame_collapse_get_delegate(System.IntPtr obj, System.IntPtr pd);
 664
 665
 666     [return: MarshalAs(UnmanagedType.U1)] public delegate bool efl_ui_frame_collapse_get_api_delegate(System.IntPtr obj);
 667     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");
 668     private static bool collapse_get(System.IntPtr obj, System.IntPtr pd)
 669    {
 670       Eina.Log.Debug("function efl_ui_frame_collapse_get was called");
 671       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
 672       if(wrapper != null) {
 673                   bool _ret_var = default(bool);
 674          try {
 675             _ret_var = ((Frame)wrapper).GetCollapse();
 676          } catch (Exception e) {
 677             Eina.Log.Warning($"Callback error: {e.ToString()}");
 678             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 679          }
 680       return _ret_var;
 681       } else {
 682          return efl_ui_frame_collapse_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
 683       }
 684    }
 685    private static efl_ui_frame_collapse_get_delegate efl_ui_frame_collapse_get_static_delegate;
 686
 687
 688     private delegate  void efl_ui_frame_collapse_set_delegate(System.IntPtr obj, System.IntPtr pd,  [MarshalAs(UnmanagedType.U1)]  bool collapse);
 689
 690
 691     public delegate  void efl_ui_frame_collapse_set_api_delegate(System.IntPtr obj,  [MarshalAs(UnmanagedType.U1)]  bool collapse);
 692     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");
 693     private static  void collapse_set(System.IntPtr obj, System.IntPtr pd,  bool collapse)
 694    {
 695       Eina.Log.Debug("function efl_ui_frame_collapse_set was called");
 696       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
 697       if(wrapper != null) {
 698
 699          try {
 700             ((Frame)wrapper).SetCollapse( collapse);
 701          } catch (Exception e) {
 702             Eina.Log.Warning($"Callback error: {e.ToString()}");
 703             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 704          }
 705                         } else {
 706          efl_ui_frame_collapse_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  collapse);
 707       }
 708    }
 709    private static efl_ui_frame_collapse_set_delegate efl_ui_frame_collapse_set_static_delegate;
 710
 711
 712     [return: MarshalAs(UnmanagedType.U1)] private delegate bool efl_ui_frame_autocollapse_get_delegate(System.IntPtr obj, System.IntPtr pd);
 713
 714
 715     [return: MarshalAs(UnmanagedType.U1)] public delegate bool efl_ui_frame_autocollapse_get_api_delegate(System.IntPtr obj);
 716     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");
 717     private static bool autocollapse_get(System.IntPtr obj, System.IntPtr pd)
 718    {
 719       Eina.Log.Debug("function efl_ui_frame_autocollapse_get was called");
 720       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
 721       if(wrapper != null) {
 722                   bool _ret_var = default(bool);
 723          try {
 724             _ret_var = ((Frame)wrapper).GetAutocollapse();
 725          } catch (Exception e) {
 726             Eina.Log.Warning($"Callback error: {e.ToString()}");
 727             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 728          }
 729       return _ret_var;
 730       } else {
 731          return efl_ui_frame_autocollapse_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
 732       }
 733    }
 734    private static efl_ui_frame_autocollapse_get_delegate efl_ui_frame_autocollapse_get_static_delegate;
 735
 736
 737     private delegate  void efl_ui_frame_autocollapse_set_delegate(System.IntPtr obj, System.IntPtr pd,  [MarshalAs(UnmanagedType.U1)]  bool autocollapse);
 738
 739
 740     public delegate  void efl_ui_frame_autocollapse_set_api_delegate(System.IntPtr obj,  [MarshalAs(UnmanagedType.U1)]  bool autocollapse);
 741     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");
 742     private static  void autocollapse_set(System.IntPtr obj, System.IntPtr pd,  bool autocollapse)
 743    {
 744       Eina.Log.Debug("function efl_ui_frame_autocollapse_set was called");
 745       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
 746       if(wrapper != null) {
 747
 748          try {
 749             ((Frame)wrapper).SetAutocollapse( autocollapse);
 750          } catch (Exception e) {
 751             Eina.Log.Warning($"Callback error: {e.ToString()}");
 752             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 753          }
 754                         } else {
 755          efl_ui_frame_autocollapse_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  autocollapse);
 756       }
 757    }
 758    private static efl_ui_frame_autocollapse_set_delegate efl_ui_frame_autocollapse_set_static_delegate;
 759
 760
 761     private delegate  void efl_ui_frame_collapse_go_delegate(System.IntPtr obj, System.IntPtr pd,  [MarshalAs(UnmanagedType.U1)]  bool collapse);
 762
 763
 764     public delegate  void efl_ui_frame_collapse_go_api_delegate(System.IntPtr obj,  [MarshalAs(UnmanagedType.U1)]  bool collapse);
 765     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");
 766     private static  void collapse_go(System.IntPtr obj, System.IntPtr pd,  bool collapse)
 767    {
 768       Eina.Log.Debug("function efl_ui_frame_collapse_go was called");
 769       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
 770       if(wrapper != null) {
 771
 772          try {
 773             ((Frame)wrapper).CollapseGo( collapse);
 774          } catch (Exception e) {
 775             Eina.Log.Warning($"Callback error: {e.ToString()}");
 776             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 777          }
 778                         } else {
 779          efl_ui_frame_collapse_go_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  collapse);
 780       }
 781    }
 782    private static efl_ui_frame_collapse_go_delegate efl_ui_frame_collapse_go_static_delegate;
 783
 784
 785    [return:MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalTest<Efl.Gfx.EntityConcrete, Efl.Eo.NonOwnTag>))] private delegate Efl.Gfx.Entity efl_content_get_delegate(System.IntPtr obj, System.IntPtr pd);
 786
 787
 788    [return:MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalTest<Efl.Gfx.EntityConcrete, Efl.Eo.NonOwnTag>))] public delegate Efl.Gfx.Entity efl_content_get_api_delegate(System.IntPtr obj);
 789     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");
 790     private static Efl.Gfx.Entity content_get(System.IntPtr obj, System.IntPtr pd)
 791    {
 792       Eina.Log.Debug("function efl_content_get was called");
 793       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
 794       if(wrapper != null) {
 795                   Efl.Gfx.Entity _ret_var = default(Efl.Gfx.Entity);
 796          try {
 797             _ret_var = ((Frame)wrapper).GetContent();
 798          } catch (Exception e) {
 799             Eina.Log.Warning($"Callback error: {e.ToString()}");
 800             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 801          }
 802       return _ret_var;
 803       } else {
 804          return efl_content_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
 805       }
 806    }
 807    private static efl_content_get_delegate efl_content_get_static_delegate;
 808
 809
 810     [return: MarshalAs(UnmanagedType.U1)] private delegate bool efl_content_set_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalTest<Efl.Gfx.EntityConcrete, Efl.Eo.NonOwnTag>))]  Efl.Gfx.Entity content);
 811
 812
 813     [return: MarshalAs(UnmanagedType.U1)] public delegate bool efl_content_set_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalTest<Efl.Gfx.EntityConcrete, Efl.Eo.NonOwnTag>))]  Efl.Gfx.Entity content);
 814     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");
 815     private static bool content_set(System.IntPtr obj, System.IntPtr pd,  Efl.Gfx.Entity content)
 816    {
 817       Eina.Log.Debug("function efl_content_set was called");
 818       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
 819       if(wrapper != null) {
 820                                     bool _ret_var = default(bool);
 821          try {
 822             _ret_var = ((Frame)wrapper).SetContent( content);
 823          } catch (Exception e) {
 824             Eina.Log.Warning($"Callback error: {e.ToString()}");
 825             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 826          }
 827                   return _ret_var;
 828       } else {
 829          return efl_content_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  content);
 830       }
 831    }
 832    private static efl_content_set_delegate efl_content_set_static_delegate;
 833
 834
 835    [return:MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalTest<Efl.Gfx.EntityConcrete, Efl.Eo.NonOwnTag>))] private delegate Efl.Gfx.Entity efl_content_unset_delegate(System.IntPtr obj, System.IntPtr pd);
 836
 837
 838    [return:MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalTest<Efl.Gfx.EntityConcrete, Efl.Eo.NonOwnTag>))] public delegate Efl.Gfx.Entity efl_content_unset_api_delegate(System.IntPtr obj);
 839     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");
 840     private static Efl.Gfx.Entity content_unset(System.IntPtr obj, System.IntPtr pd)
 841    {
 842       Eina.Log.Debug("function efl_content_unset was called");
 843       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
 844       if(wrapper != null) {
 845                   Efl.Gfx.Entity _ret_var = default(Efl.Gfx.Entity);
 846          try {
 847             _ret_var = ((Frame)wrapper).UnsetContent();
 848          } catch (Exception e) {
 849             Eina.Log.Warning($"Callback error: {e.ToString()}");
 850             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 851          }
 852       return _ret_var;
 853       } else {
 854          return efl_content_unset_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
 855       }
 856    }
 857    private static efl_content_unset_delegate efl_content_unset_static_delegate;
 858
 859
 860     [return: MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))] private delegate  System.String efl_text_get_delegate(System.IntPtr obj, System.IntPtr pd);
 861
 862
 863     [return: MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))] public delegate  System.String efl_text_get_api_delegate(System.IntPtr obj);
 864     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");
 865     private static  System.String text_get(System.IntPtr obj, System.IntPtr pd)
 866    {
 867       Eina.Log.Debug("function efl_text_get was called");
 868       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
 869       if(wrapper != null) {
 870                    System.String _ret_var = default( System.String);
 871          try {
 872             _ret_var = ((Frame)wrapper).GetText();
 873          } catch (Exception e) {
 874             Eina.Log.Warning($"Callback error: {e.ToString()}");
 875             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 876          }
 877       return _ret_var;
 878       } else {
 879          return efl_text_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
 880       }
 881    }
 882    private static efl_text_get_delegate efl_text_get_static_delegate;
 883
 884
 885     private delegate  void efl_text_set_delegate(System.IntPtr obj, System.IntPtr pd,  [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))]   System.String text);
 886
 887
 888     public delegate  void efl_text_set_api_delegate(System.IntPtr obj,  [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))]   System.String text);
 889     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");
 890     private static  void text_set(System.IntPtr obj, System.IntPtr pd,   System.String text)
 891    {
 892       Eina.Log.Debug("function efl_text_set was called");
 893       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
 894       if(wrapper != null) {
 895
 896          try {
 897             ((Frame)wrapper).SetText( text);
 898          } catch (Exception e) {
 899             Eina.Log.Warning($"Callback error: {e.ToString()}");
 900             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 901          }
 902                         } else {
 903          efl_text_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  text);
 904       }
 905    }
 906    private static efl_text_set_delegate efl_text_set_static_delegate;
 907
 908
 909     [return: MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))] private delegate  System.String efl_text_markup_get_delegate(System.IntPtr obj, System.IntPtr pd);
 910
 911
 912     [return: MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))] public delegate  System.String efl_text_markup_get_api_delegate(System.IntPtr obj);
 913     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");
 914     private static  System.String markup_get(System.IntPtr obj, System.IntPtr pd)
 915    {
 916       Eina.Log.Debug("function efl_text_markup_get was called");
 917       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
 918       if(wrapper != null) {
 919                    System.String _ret_var = default( System.String);
 920          try {
 921             _ret_var = ((Frame)wrapper).GetMarkup();
 922          } catch (Exception e) {
 923             Eina.Log.Warning($"Callback error: {e.ToString()}");
 924             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 925          }
 926       return _ret_var;
 927       } else {
 928          return efl_text_markup_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
 929       }
 930    }
 931    private static efl_text_markup_get_delegate efl_text_markup_get_static_delegate;
 932
 933
 934     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);
 935
 936
 937     public delegate  void efl_text_markup_set_api_delegate(System.IntPtr obj,  [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))]   System.String markup);
 938     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");
 939     private static  void markup_set(System.IntPtr obj, System.IntPtr pd,   System.String markup)
 940    {
 941       Eina.Log.Debug("function efl_text_markup_set was called");
 942       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
 943       if(wrapper != null) {
 944
 945          try {
 946             ((Frame)wrapper).SetMarkup( markup);
 947          } catch (Exception e) {
 948             Eina.Log.Warning($"Callback error: {e.ToString()}");
 949             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 950          }
 951                         } else {
 952          efl_text_markup_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  markup);
 953       }
 954    }
 955    private static efl_text_markup_set_delegate efl_text_markup_set_static_delegate;
 956 }
 957 } }