internals/src/EflSharp/EflSharp/efl/efl_layout_signal.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
   8 /// <summary></summary>
   9 /// <param name="kw_object">The object the callback is being triggered from.</param>
  10 /// <param name="emission">The name component of the signal.</param>
  11 /// <param name="source">The source of a signal used as context.</param>
  12 /// <returns></returns>
  13 public delegate void EflLayoutSignalCb( Efl.Layout.ISignal kw_object,  System.String emission,  System.String source);
  14 public delegate void EflLayoutSignalCbInternal(IntPtr data, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalTest<Efl.Layout.ISignalConcrete, Efl.Eo.NonOwnTag>))]  Efl.Layout.ISignal kw_object,  [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))]  System.String emission,  [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))]  System.String source);
  15 internal class EflLayoutSignalCbWrapper
  16 {
  17
  18     private EflLayoutSignalCbInternal _cb;
  19     private IntPtr _cb_data;
  20     private EinaFreeCb _cb_free_cb;
  21
  22     internal EflLayoutSignalCbWrapper (EflLayoutSignalCbInternal _cb, IntPtr _cb_data, EinaFreeCb _cb_free_cb)
  23     {
  24         this._cb = _cb;
  25         this._cb_data = _cb_data;
  26         this._cb_free_cb = _cb_free_cb;
  27     }
  28
  29     ~EflLayoutSignalCbWrapper()
  30     {
  31         if (this._cb_free_cb != null)
  32             this._cb_free_cb(this._cb_data);
  33     }
  34
  35     internal void ManagedCb( Efl.Layout.ISignal kw_object, System.String emission, System.String source)
  36     {
  37                                                                                 _cb(_cb_data,  kw_object,  emission,  source);
  38         Eina.Error.RaiseIfUnhandledException();
  39                                                             }
  40
  41         internal static void Cb(IntPtr cb_data, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalTest<Efl.Layout.ISignalConcrete, Efl.Eo.NonOwnTag>))]  Efl.Layout.ISignal kw_object,  [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))]  System.String emission,  [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))]  System.String source)
  42     {
  43         GCHandle handle = GCHandle.FromIntPtr(cb_data);
  44         EflLayoutSignalCb cb = (EflLayoutSignalCb)handle.Target;
  45
  46         try {
  47             cb( kw_object,  emission,  source);
  48         } catch (Exception e) {
  49             Eina.Log.Warning($"Callback error: {e.ToString()}");
  50             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
  51         }
  52                                                             }
  53 }
  54
  55 namespace Efl { namespace Layout {
  56 /// <summary>Layouts asynchronous messaging and signaling interface.
  57 /// (Since EFL 1.22)</summary>
  58 [ISignalNativeInherit]
  59 public interface ISignal :
  60     Efl.Eo.IWrapper, IDisposable
  61 {
  62     /// <summary>Sends an (Edje) message to a given Edje object
  63 /// This function sends an Edje message to obj and to all of its child objects, if it has any (swallowed objects are one kind of child object). Only a few types are supported: - int, - float/double, - string/stringshare, - arrays of int, float, double or strings.
  64 ///
  65 /// Messages can go both ways, from code to theme, or theme to code.
  66 ///
  67 /// The id argument as a form of code and theme defining a common interface on message communication. One should define the same IDs on both code and EDC declaration, to individualize messages (binding them to a given context).
  68 /// (Since EFL 1.22)</summary>
  69 /// <param name="id">A identification number for the message to be sent</param>
  70 /// <param name="msg">The message&apos;s payload</param>
  71 /// <returns></returns>
  72 void MessageSend( int id,  Eina.Value msg);
  73     /// <summary>Adds a callback for an arriving Edje signal, emitted by a given Edje object.
  74 /// Edje signals are one of the communication interfaces between code and a given Edje object&apos;s theme. With signals, one can communicate two string values at a time, which are: - &quot;emission&quot; value: the name of the signal, in general - &quot;source&quot; value: a name for the signal&apos;s context, in general
  75 ///
  76 /// Signals can go both ways, from code to theme, or theme to code.
  77 ///
  78 /// Though there are those common uses for the two strings, one is free to use them however they like.
  79 ///
  80 /// Signal callback registration is powerful, in the way that blobs may be used to match multiple signals at once. All the &quot;*?[&quot; set of <c>fnmatch</c>() operators can be used, both for emission and source.
  81 ///
  82 /// Edje has internal signals it will emit, automatically, on various actions taking place on group parts. For example, the mouse cursor being moved, pressed, released, etc., over a given part&apos;s area, all generate individual signals.
  83 ///
  84 /// With something like emission = &quot;mouse,down,*&quot;, source = &quot;button.*&quot; where &quot;button.*&quot; is the pattern for the names of parts implementing buttons on an interface, you&apos;d be registering for notifications on events of mouse buttons being pressed down on either of those parts (those events all have the &quot;mouse,down,&quot; common prefix on their names, with a suffix giving the button number). The actual emission and source strings of an event will be passed in as the emission and source parameters of the callback function (e.g. &quot;mouse,down,2&quot; and &quot;button.close&quot;), for each of those events.
  85 ///
  86 /// See also the Edje Data Collection Reference for EDC files.
  87 ///
  88 /// See <see cref="Efl.Layout.ISignal.EmitSignal"/> on how to emit signals from code to a an object See <see cref="Efl.Layout.ISignal.DelSignalCallback"/>.
  89 /// (Since EFL 1.22)</summary>
  90 /// <param name="emission">The signal&apos;s &quot;emission&quot; string</param>
  91 /// <param name="source">The signal&apos;s &quot;source&quot; string</param>
  92 /// <param name="func">The callback function to be executed when the signal is emitted.</param>
  93 /// <returns><c>true</c> in case of success, <c>false</c> in case of error.</returns>
  94 bool AddSignalCallback( System.String emission,  System.String source,  EflLayoutSignalCb func);
  95     /// <summary>Removes a signal-triggered callback from an object.
  96 /// This function removes a callback, previously attached to the emission of a signal, from the object  obj. The parameters emission, source and func must match exactly those passed to a previous call to <see cref="Efl.Layout.ISignal.AddSignalCallback"/>.
  97 ///
  98 /// See <see cref="Efl.Layout.ISignal.AddSignalCallback"/>.
  99 /// (Since EFL 1.22)</summary>
 100 /// <param name="emission">The signal&apos;s &quot;emission&quot; string</param>
 101 /// <param name="source">The signal&apos;s &quot;source&quot; string</param>
 102 /// <param name="func">The callback function to be executed when the signal is emitted.</param>
 103 /// <returns><c>true</c> in case of success, <c>false</c> in case of error.</returns>
 104 bool DelSignalCallback( System.String emission,  System.String source,  EflLayoutSignalCb func);
 105     /// <summary>Sends/emits an Edje signal to this layout.
 106 /// This function sends a signal to the object. An Edje program, at the EDC specification level, can respond to a signal by having declared matching &quot;signal&quot; and &quot;source&quot; fields on its block.
 107 ///
 108 /// See also the Edje Data Collection Reference for EDC files.
 109 ///
 110 /// See <see cref="Efl.Layout.ISignal.AddSignalCallback"/> for more on Edje signals.
 111 /// (Since EFL 1.22)</summary>
 112 /// <param name="emission">The signal&apos;s &quot;emission&quot; string</param>
 113 /// <param name="source">The signal&apos;s &quot;source&quot; string</param>
 114 /// <returns></returns>
 115 void EmitSignal( System.String emission,  System.String source);
 116     /// <summary>Processes an object&apos;s messages and signals queue.
 117 /// This function goes through the object message queue processing the pending messages for this specific Edje object. Normally they&apos;d be processed only at idle time.
 118 ///
 119 /// If <c>recurse</c> is <c>true</c>, this function will be called recursively on all subobjects.
 120 /// (Since EFL 1.22)</summary>
 121 /// <param name="recurse">Whether to process messages on children objects.</param>
 122 /// <returns></returns>
 123 void SignalProcess( bool recurse);
 124                     }
 125 /// <summary>Layouts asynchronous messaging and signaling interface.
 126 /// (Since EFL 1.22)</summary>
 127 sealed public class ISignalConcrete :
 128
 129 ISignal
 130
 131 {
 132     ///<summary>Pointer to the native class description.</summary>
 133     public System.IntPtr NativeClass {
 134         get {
 135             if (((object)this).GetType() == typeof (ISignalConcrete))
 136                 return Efl.Layout.ISignalNativeInherit.GetEflClassStatic();
 137             else
 138                 return Efl.Eo.ClassRegister.klassFromType[((object)this).GetType()];
 139         }
 140     }
 141     private  System.IntPtr handle;
 142     ///<summary>Pointer to the native instance.</summary>
 143     public System.IntPtr NativeHandle {
 144         get { return handle; }
 145     }
 146     [System.Runtime.InteropServices.DllImport(efl.Libs.Edje)] internal static extern System.IntPtr
 147         efl_layout_signal_interface_get();
 148     ///<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>
 149     private ISignalConcrete(System.IntPtr raw)
 150     {
 151         handle = raw;
 152         RegisterEventProxies();
 153     }
 154     ///<summary>Destructor.</summary>
 155     ~ISignalConcrete()
 156     {
 157         Dispose(false);
 158     }
 159     ///<summary>Releases the underlying native instance.</summary>
 160     void Dispose(bool disposing)
 161     {
 162         if (handle != System.IntPtr.Zero) {
 163             Efl.Eo.Globals.efl_unref(handle);
 164             handle = System.IntPtr.Zero;
 165         }
 166     }
 167     ///<summary>Releases the underlying native instance.</summary>
 168     public void Dispose()
 169     {
 170         Dispose(true);
 171         GC.SuppressFinalize(this);
 172     }
 173     ///<summary>Verifies if the given object is equal to this one.</summary>
 174     public override bool Equals(object obj)
 175     {
 176         var other = obj as Efl.Object;
 177         if (other == null)
 178             return false;
 179         return this.NativeHandle == other.NativeHandle;
 180     }
 181     ///<summary>Gets the hash code for this object based on the native pointer it points to.</summary>
 182     public override int GetHashCode()
 183     {
 184         return this.NativeHandle.ToInt32();
 185     }
 186     ///<summary>Turns the native pointer into a string representation.</summary>
 187     public override String ToString()
 188     {
 189         return $"{this.GetType().Name}@[{this.NativeHandle.ToInt32():x}]";
 190     }
 191     ///<summary>Register the Eo event wrappers making the bridge to C# events. Internal usage only.</summary>
 192      void RegisterEventProxies()
 193     {
 194     }
 195     /// <summary>Sends an (Edje) message to a given Edje object
 196     /// This function sends an Edje message to obj and to all of its child objects, if it has any (swallowed objects are one kind of child object). Only a few types are supported: - int, - float/double, - string/stringshare, - arrays of int, float, double or strings.
 197     ///
 198     /// Messages can go both ways, from code to theme, or theme to code.
 199     ///
 200     /// The id argument as a form of code and theme defining a common interface on message communication. One should define the same IDs on both code and EDC declaration, to individualize messages (binding them to a given context).
 201     /// (Since EFL 1.22)</summary>
 202     /// <param name="id">A identification number for the message to be sent</param>
 203     /// <param name="msg">The message&apos;s payload</param>
 204     /// <returns></returns>
 205     public void MessageSend( int id,  Eina.Value msg) {
 206                                                          Efl.Layout.ISignalNativeInherit.efl_layout_signal_message_send_ptr.Value.Delegate(this.NativeHandle, id,  msg);
 207         Eina.Error.RaiseIfUnhandledException();
 208                                          }
 209     /// <summary>Adds a callback for an arriving Edje signal, emitted by a given Edje object.
 210     /// Edje signals are one of the communication interfaces between code and a given Edje object&apos;s theme. With signals, one can communicate two string values at a time, which are: - &quot;emission&quot; value: the name of the signal, in general - &quot;source&quot; value: a name for the signal&apos;s context, in general
 211     ///
 212     /// Signals can go both ways, from code to theme, or theme to code.
 213     ///
 214     /// Though there are those common uses for the two strings, one is free to use them however they like.
 215     ///
 216     /// Signal callback registration is powerful, in the way that blobs may be used to match multiple signals at once. All the &quot;*?[&quot; set of <c>fnmatch</c>() operators can be used, both for emission and source.
 217     ///
 218     /// Edje has internal signals it will emit, automatically, on various actions taking place on group parts. For example, the mouse cursor being moved, pressed, released, etc., over a given part&apos;s area, all generate individual signals.
 219     ///
 220     /// With something like emission = &quot;mouse,down,*&quot;, source = &quot;button.*&quot; where &quot;button.*&quot; is the pattern for the names of parts implementing buttons on an interface, you&apos;d be registering for notifications on events of mouse buttons being pressed down on either of those parts (those events all have the &quot;mouse,down,&quot; common prefix on their names, with a suffix giving the button number). The actual emission and source strings of an event will be passed in as the emission and source parameters of the callback function (e.g. &quot;mouse,down,2&quot; and &quot;button.close&quot;), for each of those events.
 221     ///
 222     /// See also the Edje Data Collection Reference for EDC files.
 223     ///
 224     /// See <see cref="Efl.Layout.ISignal.EmitSignal"/> on how to emit signals from code to a an object See <see cref="Efl.Layout.ISignal.DelSignalCallback"/>.
 225     /// (Since EFL 1.22)</summary>
 226     /// <param name="emission">The signal&apos;s &quot;emission&quot; string</param>
 227     /// <param name="source">The signal&apos;s &quot;source&quot; string</param>
 228     /// <param name="func">The callback function to be executed when the signal is emitted.</param>
 229     /// <returns><c>true</c> in case of success, <c>false</c> in case of error.</returns>
 230     public bool AddSignalCallback( System.String emission,  System.String source,  EflLayoutSignalCb func) {
 231                                                                          GCHandle func_handle = GCHandle.Alloc(func);
 232         var _ret_var = Efl.Layout.ISignalNativeInherit.efl_layout_signal_callback_add_ptr.Value.Delegate(this.NativeHandle, emission,  source, GCHandle.ToIntPtr(func_handle), EflLayoutSignalCbWrapper.Cb, Efl.Eo.Globals.free_gchandle);
 233         Eina.Error.RaiseIfUnhandledException();
 234                                                         return _ret_var;
 235  }
 236     /// <summary>Removes a signal-triggered callback from an object.
 237     /// This function removes a callback, previously attached to the emission of a signal, from the object  obj. The parameters emission, source and func must match exactly those passed to a previous call to <see cref="Efl.Layout.ISignal.AddSignalCallback"/>.
 238     ///
 239     /// See <see cref="Efl.Layout.ISignal.AddSignalCallback"/>.
 240     /// (Since EFL 1.22)</summary>
 241     /// <param name="emission">The signal&apos;s &quot;emission&quot; string</param>
 242     /// <param name="source">The signal&apos;s &quot;source&quot; string</param>
 243     /// <param name="func">The callback function to be executed when the signal is emitted.</param>
 244     /// <returns><c>true</c> in case of success, <c>false</c> in case of error.</returns>
 245     public bool DelSignalCallback( System.String emission,  System.String source,  EflLayoutSignalCb func) {
 246                                                                          GCHandle func_handle = GCHandle.Alloc(func);
 247         var _ret_var = Efl.Layout.ISignalNativeInherit.efl_layout_signal_callback_del_ptr.Value.Delegate(this.NativeHandle, emission,  source, GCHandle.ToIntPtr(func_handle), EflLayoutSignalCbWrapper.Cb, Efl.Eo.Globals.free_gchandle);
 248         Eina.Error.RaiseIfUnhandledException();
 249                                                         return _ret_var;
 250  }
 251     /// <summary>Sends/emits an Edje signal to this layout.
 252     /// This function sends a signal to the object. An Edje program, at the EDC specification level, can respond to a signal by having declared matching &quot;signal&quot; and &quot;source&quot; fields on its block.
 253     ///
 254     /// See also the Edje Data Collection Reference for EDC files.
 255     ///
 256     /// See <see cref="Efl.Layout.ISignal.AddSignalCallback"/> for more on Edje signals.
 257     /// (Since EFL 1.22)</summary>
 258     /// <param name="emission">The signal&apos;s &quot;emission&quot; string</param>
 259     /// <param name="source">The signal&apos;s &quot;source&quot; string</param>
 260     /// <returns></returns>
 261     public void EmitSignal( System.String emission,  System.String source) {
 262                                                          Efl.Layout.ISignalNativeInherit.efl_layout_signal_emit_ptr.Value.Delegate(this.NativeHandle, emission,  source);
 263         Eina.Error.RaiseIfUnhandledException();
 264                                          }
 265     /// <summary>Processes an object&apos;s messages and signals queue.
 266     /// This function goes through the object message queue processing the pending messages for this specific Edje object. Normally they&apos;d be processed only at idle time.
 267     ///
 268     /// If <c>recurse</c> is <c>true</c>, this function will be called recursively on all subobjects.
 269     /// (Since EFL 1.22)</summary>
 270     /// <param name="recurse">Whether to process messages on children objects.</param>
 271     /// <returns></returns>
 272     public void SignalProcess( bool recurse) {
 273                                  Efl.Layout.ISignalNativeInherit.efl_layout_signal_process_ptr.Value.Delegate(this.NativeHandle, recurse);
 274         Eina.Error.RaiseIfUnhandledException();
 275                          }
 276     private static IntPtr GetEflClassStatic()
 277     {
 278         return Efl.Layout.ISignalConcrete.efl_layout_signal_interface_get();
 279     }
 280 }
 281 public class ISignalNativeInherit  : Efl.Eo.NativeClass{
 282     public  static Efl.Eo.NativeModule _Module = new Efl.Eo.NativeModule(efl.Libs.Edje);
 283     public override System.Collections.Generic.List<Efl_Op_Description> GetEoOps(System.Type type)
 284     {
 285         var descs = new System.Collections.Generic.List<Efl_Op_Description>();
 286         var methods = Efl.Eo.Globals.GetUserMethods(type);
 287         if (efl_layout_signal_message_send_static_delegate == null)
 288             efl_layout_signal_message_send_static_delegate = new efl_layout_signal_message_send_delegate(message_send);
 289         if (methods.FirstOrDefault(m => m.Name == "MessageSend") != null)
 290             descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_layout_signal_message_send"), func = Marshal.GetFunctionPointerForDelegate(efl_layout_signal_message_send_static_delegate)});
 291         if (efl_layout_signal_callback_add_static_delegate == null)
 292             efl_layout_signal_callback_add_static_delegate = new efl_layout_signal_callback_add_delegate(signal_callback_add);
 293         if (methods.FirstOrDefault(m => m.Name == "AddSignalCallback") != null)
 294             descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_layout_signal_callback_add"), func = Marshal.GetFunctionPointerForDelegate(efl_layout_signal_callback_add_static_delegate)});
 295         if (efl_layout_signal_callback_del_static_delegate == null)
 296             efl_layout_signal_callback_del_static_delegate = new efl_layout_signal_callback_del_delegate(signal_callback_del);
 297         if (methods.FirstOrDefault(m => m.Name == "DelSignalCallback") != null)
 298             descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_layout_signal_callback_del"), func = Marshal.GetFunctionPointerForDelegate(efl_layout_signal_callback_del_static_delegate)});
 299         if (efl_layout_signal_emit_static_delegate == null)
 300             efl_layout_signal_emit_static_delegate = new efl_layout_signal_emit_delegate(signal_emit);
 301         if (methods.FirstOrDefault(m => m.Name == "EmitSignal") != null)
 302             descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_layout_signal_emit"), func = Marshal.GetFunctionPointerForDelegate(efl_layout_signal_emit_static_delegate)});
 303         if (efl_layout_signal_process_static_delegate == null)
 304             efl_layout_signal_process_static_delegate = new efl_layout_signal_process_delegate(signal_process);
 305         if (methods.FirstOrDefault(m => m.Name == "SignalProcess") != null)
 306             descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_layout_signal_process"), func = Marshal.GetFunctionPointerForDelegate(efl_layout_signal_process_static_delegate)});
 307         return descs;
 308     }
 309     public override IntPtr GetEflClass()
 310     {
 311         return Efl.Layout.ISignalConcrete.efl_layout_signal_interface_get();
 312     }
 313     public static  IntPtr GetEflClassStatic()
 314     {
 315         return Efl.Layout.ISignalConcrete.efl_layout_signal_interface_get();
 316     }
 317
 318
 319      private delegate void efl_layout_signal_message_send_delegate(System.IntPtr obj, System.IntPtr pd,   int id,   Eina.ValueNative msg);
 320
 321
 322      public delegate void efl_layout_signal_message_send_api_delegate(System.IntPtr obj,   int id,   Eina.ValueNative msg);
 323      public static Efl.Eo.FunctionWrapper<efl_layout_signal_message_send_api_delegate> efl_layout_signal_message_send_ptr = new Efl.Eo.FunctionWrapper<efl_layout_signal_message_send_api_delegate>(_Module, "efl_layout_signal_message_send");
 324      private static void message_send(System.IntPtr obj, System.IntPtr pd,  int id,  Eina.ValueNative msg)
 325     {
 326         Eina.Log.Debug("function efl_layout_signal_message_send was called");
 327         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
 328         if(wrapper != null) {
 329
 330             try {
 331                 ((ISignal)wrapper).MessageSend( id,  msg);
 332             } catch (Exception e) {
 333                 Eina.Log.Warning($"Callback error: {e.ToString()}");
 334                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 335             }
 336                                                 } else {
 337             efl_layout_signal_message_send_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  id,  msg);
 338         }
 339     }
 340     private static efl_layout_signal_message_send_delegate efl_layout_signal_message_send_static_delegate;
 341
 342
 343      [return: MarshalAs(UnmanagedType.U1)] private delegate bool efl_layout_signal_callback_add_delegate(System.IntPtr obj, System.IntPtr pd,  [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))]  System.String emission,  [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))]  System.String source,  IntPtr func_data, EflLayoutSignalCbInternal func, EinaFreeCb func_free_cb);
 344
 345
 346      [return: MarshalAs(UnmanagedType.U1)] public delegate bool efl_layout_signal_callback_add_api_delegate(System.IntPtr obj,  [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))]  System.String emission,  [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))]  System.String source,  IntPtr func_data, EflLayoutSignalCbInternal func, EinaFreeCb func_free_cb);
 347      public static Efl.Eo.FunctionWrapper<efl_layout_signal_callback_add_api_delegate> efl_layout_signal_callback_add_ptr = new Efl.Eo.FunctionWrapper<efl_layout_signal_callback_add_api_delegate>(_Module, "efl_layout_signal_callback_add");
 348      private static bool signal_callback_add(System.IntPtr obj, System.IntPtr pd,  System.String emission,  System.String source, IntPtr func_data, EflLayoutSignalCbInternal func, EinaFreeCb func_free_cb)
 349     {
 350         Eina.Log.Debug("function efl_layout_signal_callback_add was called");
 351         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
 352         if(wrapper != null) {
 353                                                                                         EflLayoutSignalCbWrapper func_wrapper = new EflLayoutSignalCbWrapper(func, func_data, func_free_cb);
 354             bool _ret_var = default(bool);
 355             try {
 356                 _ret_var = ((ISignal)wrapper).AddSignalCallback( emission,  source,  func_wrapper.ManagedCb);
 357             } catch (Exception e) {
 358                 Eina.Log.Warning($"Callback error: {e.ToString()}");
 359                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 360             }
 361                                                         return _ret_var;
 362         } else {
 363             return efl_layout_signal_callback_add_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  emission,  source, func_data, func, func_free_cb);
 364         }
 365     }
 366     private static efl_layout_signal_callback_add_delegate efl_layout_signal_callback_add_static_delegate;
 367
 368
 369      [return: MarshalAs(UnmanagedType.U1)] private delegate bool efl_layout_signal_callback_del_delegate(System.IntPtr obj, System.IntPtr pd,  [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))]  System.String emission,  [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))]  System.String source,  IntPtr func_data, EflLayoutSignalCbInternal func, EinaFreeCb func_free_cb);
 370
 371
 372      [return: MarshalAs(UnmanagedType.U1)] public delegate bool efl_layout_signal_callback_del_api_delegate(System.IntPtr obj,  [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))]  System.String emission,  [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))]  System.String source,  IntPtr func_data, EflLayoutSignalCbInternal func, EinaFreeCb func_free_cb);
 373      public static Efl.Eo.FunctionWrapper<efl_layout_signal_callback_del_api_delegate> efl_layout_signal_callback_del_ptr = new Efl.Eo.FunctionWrapper<efl_layout_signal_callback_del_api_delegate>(_Module, "efl_layout_signal_callback_del");
 374      private static bool signal_callback_del(System.IntPtr obj, System.IntPtr pd,  System.String emission,  System.String source, IntPtr func_data, EflLayoutSignalCbInternal func, EinaFreeCb func_free_cb)
 375     {
 376         Eina.Log.Debug("function efl_layout_signal_callback_del was called");
 377         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
 378         if(wrapper != null) {
 379                                                                                         EflLayoutSignalCbWrapper func_wrapper = new EflLayoutSignalCbWrapper(func, func_data, func_free_cb);
 380             bool _ret_var = default(bool);
 381             try {
 382                 _ret_var = ((ISignal)wrapper).DelSignalCallback( emission,  source,  func_wrapper.ManagedCb);
 383             } catch (Exception e) {
 384                 Eina.Log.Warning($"Callback error: {e.ToString()}");
 385                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 386             }
 387                                                         return _ret_var;
 388         } else {
 389             return efl_layout_signal_callback_del_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  emission,  source, func_data, func, func_free_cb);
 390         }
 391     }
 392     private static efl_layout_signal_callback_del_delegate efl_layout_signal_callback_del_static_delegate;
 393
 394
 395      private delegate void efl_layout_signal_emit_delegate(System.IntPtr obj, System.IntPtr pd,  [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))]  System.String emission,  [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))]  System.String source);
 396
 397
 398      public delegate void efl_layout_signal_emit_api_delegate(System.IntPtr obj,  [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))]  System.String emission,  [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))]  System.String source);
 399      public static Efl.Eo.FunctionWrapper<efl_layout_signal_emit_api_delegate> efl_layout_signal_emit_ptr = new Efl.Eo.FunctionWrapper<efl_layout_signal_emit_api_delegate>(_Module, "efl_layout_signal_emit");
 400      private static void signal_emit(System.IntPtr obj, System.IntPtr pd,  System.String emission,  System.String source)
 401     {
 402         Eina.Log.Debug("function efl_layout_signal_emit was called");
 403         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
 404         if(wrapper != null) {
 405
 406             try {
 407                 ((ISignal)wrapper).EmitSignal( emission,  source);
 408             } catch (Exception e) {
 409                 Eina.Log.Warning($"Callback error: {e.ToString()}");
 410                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 411             }
 412                                                 } else {
 413             efl_layout_signal_emit_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  emission,  source);
 414         }
 415     }
 416     private static efl_layout_signal_emit_delegate efl_layout_signal_emit_static_delegate;
 417
 418
 419      private delegate void efl_layout_signal_process_delegate(System.IntPtr obj, System.IntPtr pd,  [MarshalAs(UnmanagedType.U1)]  bool recurse);
 420
 421
 422      public delegate void efl_layout_signal_process_api_delegate(System.IntPtr obj,  [MarshalAs(UnmanagedType.U1)]  bool recurse);
 423      public static Efl.Eo.FunctionWrapper<efl_layout_signal_process_api_delegate> efl_layout_signal_process_ptr = new Efl.Eo.FunctionWrapper<efl_layout_signal_process_api_delegate>(_Module, "efl_layout_signal_process");
 424      private static void signal_process(System.IntPtr obj, System.IntPtr pd,  bool recurse)
 425     {
 426         Eina.Log.Debug("function efl_layout_signal_process was called");
 427         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
 428         if(wrapper != null) {
 429
 430             try {
 431                 ((ISignal)wrapper).SignalProcess( recurse);
 432             } catch (Exception e) {
 433                 Eina.Log.Warning($"Callback error: {e.ToString()}");
 434                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 435             }
 436                                 } else {
 437             efl_layout_signal_process_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  recurse);
 438         }
 439     }
 440     private static efl_layout_signal_process_delegate efl_layout_signal_process_static_delegate;
 441 }
 442 } }