internals/src/EflSharp/EflSharp/efl/efl_canvas_event_grabber.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 Canvas {
  11
  12 /// <summary>Low-level rectangle object.
  13 /// This provides a smart version of the typical &quot;event rectangle&quot;, which allows objects to set this as their parent and route events to a group of objects. Events will not propagate to non-member objects below this object.
  14 ///
  15 /// Adding members is done just like a normal smart object, using efl_canvas_group_member_add (Eo API) or evas_object_smart_member_add (legacy).
  16 ///
  17 /// Child objects are not modified in any way, unlike other types of smart objects.
  18 ///
  19 /// No child objects should be stacked above the event grabber parent while the grabber is visible. A critical error will be raised if this is detected.</summary>
  20 [Efl.Canvas.EventGrabber.NativeMethods]
  21 [Efl.Eo.BindingEntity]
  22 public class EventGrabber : Efl.Canvas.Group
  23 {
  24     ///<summary>Pointer to the native class description.</summary>
  25     public override System.IntPtr NativeClass
  26     {
  27         get
  28         {
  29             if (((object)this).GetType() == typeof(EventGrabber))
  30             {
  31                 return GetEflClassStatic();
  32             }
  33             else
  34             {
  35                 return Efl.Eo.ClassRegister.klassFromType[((object)this).GetType()];
  36             }
  37         }
  38     }
  39
  40     [System.Runtime.InteropServices.DllImport(efl.Libs.Evas)] internal static extern System.IntPtr
  41         efl_canvas_event_grabber_class_get();
  42     /// <summary>Initializes a new instance of the <see cref="EventGrabber"/> class.</summary>
  43     /// <param name="parent">Parent instance.</param>
  44     public EventGrabber(Efl.Object parent= null
  45             ) : base(efl_canvas_event_grabber_class_get(), parent)
  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 EventGrabber(ConstructingHandle ch) : base(ch)
  53     {
  54     }
  55
  56     /// <summary>Initializes a new instance of the <see cref="EventGrabber"/> 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 EventGrabber(Efl.Eo.Globals.WrappingHandle wh) : base(wh)
  60     {
  61     }
  62
  63     /// <summary>Initializes a new instance of the <see cref="EventGrabber"/> 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 EventGrabber(IntPtr baseKlass, Efl.Object parent) : base(baseKlass, parent)
  68     {
  69     }
  70
  71     /// <summary>Stops the grabber from updating its internal stacking order while visible</summary>
  72     /// <returns>If <c>true</c>, stop updating</returns>
  73     virtual public bool GetFreezeWhenVisible() {
  74          var _ret_var = Efl.Canvas.EventGrabber.NativeMethods.efl_canvas_event_grabber_freeze_when_visible_get_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)));
  75         Eina.Error.RaiseIfUnhandledException();
  76         return _ret_var;
  77  }
  78     /// <summary>Stops the grabber from updating its internal stacking order while visible</summary>
  79     /// <param name="set">If <c>true</c>, stop updating</param>
  80     virtual public void SetFreezeWhenVisible(bool set) {
  81                                  Efl.Canvas.EventGrabber.NativeMethods.efl_canvas_event_grabber_freeze_when_visible_set_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)),set);
  82         Eina.Error.RaiseIfUnhandledException();
  83                          }
  84     /// <summary>Stops the grabber from updating its internal stacking order while visible</summary>
  85     /// <value>If <c>true</c>, stop updating</value>
  86     public bool FreezeWhenVisible {
  87         get { return GetFreezeWhenVisible(); }
  88         set { SetFreezeWhenVisible(value); }
  89     }
  90     private static IntPtr GetEflClassStatic()
  91     {
  92         return Efl.Canvas.EventGrabber.efl_canvas_event_grabber_class_get();
  93     }
  94     /// <summary>Wrapper for native methods and virtual method delegates.
  95     /// For internal use by generated code only.</summary>
  96     public new class NativeMethods : Efl.Canvas.Group.NativeMethods
  97     {
  98         private static Efl.Eo.NativeModule Module = new Efl.Eo.NativeModule(    efl.Libs.Evas);
  99         /// <summary>Gets the list of Eo operations to override.</summary>
 100         /// <returns>The list of Eo operations to be overload.</returns>
 101         public override System.Collections.Generic.List<Efl_Op_Description> GetEoOps(System.Type type)
 102         {
 103             var descs = new System.Collections.Generic.List<Efl_Op_Description>();
 104             var methods = Efl.Eo.Globals.GetUserMethods(type);
 105
 106             if (efl_canvas_event_grabber_freeze_when_visible_get_static_delegate == null)
 107             {
 108                 efl_canvas_event_grabber_freeze_when_visible_get_static_delegate = new efl_canvas_event_grabber_freeze_when_visible_get_delegate(freeze_when_visible_get);
 109             }
 110
 111             if (methods.FirstOrDefault(m => m.Name == "GetFreezeWhenVisible") != null)
 112             {
 113                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_canvas_event_grabber_freeze_when_visible_get"), func = Marshal.GetFunctionPointerForDelegate(efl_canvas_event_grabber_freeze_when_visible_get_static_delegate) });
 114             }
 115
 116             if (efl_canvas_event_grabber_freeze_when_visible_set_static_delegate == null)
 117             {
 118                 efl_canvas_event_grabber_freeze_when_visible_set_static_delegate = new efl_canvas_event_grabber_freeze_when_visible_set_delegate(freeze_when_visible_set);
 119             }
 120
 121             if (methods.FirstOrDefault(m => m.Name == "SetFreezeWhenVisible") != null)
 122             {
 123                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_canvas_event_grabber_freeze_when_visible_set"), func = Marshal.GetFunctionPointerForDelegate(efl_canvas_event_grabber_freeze_when_visible_set_static_delegate) });
 124             }
 125
 126             descs.AddRange(base.GetEoOps(type));
 127             return descs;
 128         }
 129         /// <summary>Returns the Eo class for the native methods of this class.</summary>
 130         /// <returns>The native class pointer.</returns>
 131         public override IntPtr GetEflClass()
 132         {
 133             return Efl.Canvas.EventGrabber.efl_canvas_event_grabber_class_get();
 134         }
 135
 136         #pragma warning disable CA1707, CS1591, SA1300, SA1600
 137
 138         [return: MarshalAs(UnmanagedType.U1)]
 139         private delegate bool efl_canvas_event_grabber_freeze_when_visible_get_delegate(System.IntPtr obj, System.IntPtr pd);
 140
 141         [return: MarshalAs(UnmanagedType.U1)]
 142         public delegate bool efl_canvas_event_grabber_freeze_when_visible_get_api_delegate(System.IntPtr obj);
 143
 144         public static Efl.Eo.FunctionWrapper<efl_canvas_event_grabber_freeze_when_visible_get_api_delegate> efl_canvas_event_grabber_freeze_when_visible_get_ptr = new Efl.Eo.FunctionWrapper<efl_canvas_event_grabber_freeze_when_visible_get_api_delegate>(Module, "efl_canvas_event_grabber_freeze_when_visible_get");
 145
 146         private static bool freeze_when_visible_get(System.IntPtr obj, System.IntPtr pd)
 147         {
 148             Eina.Log.Debug("function efl_canvas_event_grabber_freeze_when_visible_get was called");
 149             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 150             if (ws != null)
 151             {
 152             bool _ret_var = default(bool);
 153                 try
 154                 {
 155                     _ret_var = ((EventGrabber)ws.Target).GetFreezeWhenVisible();
 156                 }
 157                 catch (Exception e)
 158                 {
 159                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 160                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 161                 }
 162
 163         return _ret_var;
 164
 165             }
 166             else
 167             {
 168                 return efl_canvas_event_grabber_freeze_when_visible_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
 169             }
 170         }
 171
 172         private static efl_canvas_event_grabber_freeze_when_visible_get_delegate efl_canvas_event_grabber_freeze_when_visible_get_static_delegate;
 173
 174
 175         private delegate void efl_canvas_event_grabber_freeze_when_visible_set_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.U1)] bool set);
 176
 177
 178         public delegate void efl_canvas_event_grabber_freeze_when_visible_set_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.U1)] bool set);
 179
 180         public static Efl.Eo.FunctionWrapper<efl_canvas_event_grabber_freeze_when_visible_set_api_delegate> efl_canvas_event_grabber_freeze_when_visible_set_ptr = new Efl.Eo.FunctionWrapper<efl_canvas_event_grabber_freeze_when_visible_set_api_delegate>(Module, "efl_canvas_event_grabber_freeze_when_visible_set");
 181
 182         private static void freeze_when_visible_set(System.IntPtr obj, System.IntPtr pd, bool set)
 183         {
 184             Eina.Log.Debug("function efl_canvas_event_grabber_freeze_when_visible_set was called");
 185             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 186             if (ws != null)
 187             {
 188
 189                 try
 190                 {
 191                     ((EventGrabber)ws.Target).SetFreezeWhenVisible(set);
 192                 }
 193                 catch (Exception e)
 194                 {
 195                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 196                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 197                 }
 198
 199
 200             }
 201             else
 202             {
 203                 efl_canvas_event_grabber_freeze_when_visible_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), set);
 204             }
 205         }
 206
 207         private static efl_canvas_event_grabber_freeze_when_visible_set_delegate efl_canvas_event_grabber_freeze_when_visible_set_static_delegate;
 208
 209         #pragma warning restore CA1707, CS1591, SA1300, SA1600
 210
 211 }
 212 }
 213 }
 214
 215 }
 216