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.Threading;
   7 using System.ComponentModel;
   8 /// <param name="kw_object">The object the callback is being triggered from.</param>
   9 /// <param name="emission">The name component of the signal.</param>
  10 /// <param name="source">The source of a signal used as context.</param>
  11 public delegate void EflLayoutSignalCb(Efl.Layout.ISignal kw_object, System.String emission, System.String source);
  12 public delegate void EflLayoutSignalCbInternal(IntPtr data, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<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);
  13 internal class EflLayoutSignalCbWrapper : IDisposable
  14 {
  15
  16     private EflLayoutSignalCbInternal _cb;
  17     private IntPtr _cb_data;
  18     private EinaFreeCb _cb_free_cb;
  19
  20     internal EflLayoutSignalCbWrapper (EflLayoutSignalCbInternal _cb, IntPtr _cb_data, EinaFreeCb _cb_free_cb)
  21     {
  22         this._cb = _cb;
  23         this._cb_data = _cb_data;
  24         this._cb_free_cb = _cb_free_cb;
  25     }
  26
  27     ~EflLayoutSignalCbWrapper()
  28     {
  29         Dispose(false);
  30     }
  31
  32     protected virtual void Dispose(bool disposing)
  33     {
  34         if (this._cb_free_cb != null)
  35         {
  36             if (disposing)
  37             {
  38                 this._cb_free_cb(this._cb_data);
  39             }
  40             else
  41             {
  42                 Efl.Eo.Globals.ThreadSafeFreeCbExec(this._cb_free_cb, this._cb_data);
  43             }
  44             this._cb_free_cb = null;
  45             this._cb_data = IntPtr.Zero;
  46             this._cb = null;
  47         }
  48     }
  49
  50     public void Dispose()
  51     {
  52         Dispose(true);
  53         GC.SuppressFinalize(this);
  54     }
  55
  56     internal void ManagedCb(Efl.Layout.ISignal kw_object,System.String emission,System.String source)
  57     {
  58                                                                                 _cb(_cb_data, kw_object, emission, source);
  59         Eina.Error.RaiseIfUnhandledException();
  60                                                             }
  61
  62         internal static void Cb(IntPtr cb_data, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<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)
  63     {
  64         GCHandle handle = GCHandle.FromIntPtr(cb_data);
  65         EflLayoutSignalCb cb = (EflLayoutSignalCb)handle.Target;
  66
  67         try {
  68             cb(kw_object, emission, source);
  69         } catch (Exception e) {
  70             Eina.Log.Warning($"Callback error: {e.ToString()}");
  71             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
  72         }
  73                                                             }
  74 }
  75
  76
  77 namespace Efl {
  78
  79 namespace Layout {
  80
  81 /// <summary>Layouts asynchronous messaging and signaling interface.
  82 /// (Since EFL 1.22)</summary>
  83 [Efl.Layout.ISignalConcrete.NativeMethods]
  84 public interface ISignal :
  85     Efl.Eo.IWrapper, IDisposable
  86 {
  87     /// <summary>Sends an (Edje) message to a given Edje object
  88 /// 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.
  89 ///
  90 /// Messages can go both ways, from code to theme, or theme to code.
  91 ///
  92 /// 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).
  93 /// (Since EFL 1.22)</summary>
  94 /// <param name="id">A identification number for the message to be sent</param>
  95 /// <param name="msg">The message&apos;s payload</param>
  96 void MessageSend(int id, Eina.Value msg);
  97     /// <summary>Adds a callback for an arriving Edje signal, emitted by a given Edje object.
  98 /// 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
  99 ///
 100 /// Signals can go both ways, from code to theme, or theme to code.
 101 ///
 102 /// Though there are those common uses for the two strings, one is free to use them however they like.
 103 ///
 104 /// 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.
 105 ///
 106 /// 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.
 107 ///
 108 /// 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.
 109 ///
 110 /// See also the Edje Data Collection Reference for EDC files.
 111 ///
 112 /// 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"/>.
 113 /// (Since EFL 1.22)</summary>
 114 /// <param name="emission">The signal&apos;s &quot;emission&quot; string</param>
 115 /// <param name="source">The signal&apos;s &quot;source&quot; string</param>
 116 /// <param name="func">The callback function to be executed when the signal is emitted.</param>
 117 /// <returns><c>true</c> in case of success, <c>false</c> in case of error.</returns>
 118 bool AddSignalCallback(System.String emission, System.String source, EflLayoutSignalCb func);
 119     /// <summary>Removes a signal-triggered callback from an object.
 120 /// 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"/>.
 121 ///
 122 /// See <see cref="Efl.Layout.ISignal.AddSignalCallback"/>.
 123 /// (Since EFL 1.22)</summary>
 124 /// <param name="emission">The signal&apos;s &quot;emission&quot; string</param>
 125 /// <param name="source">The signal&apos;s &quot;source&quot; string</param>
 126 /// <param name="func">The callback function to be executed when the signal is emitted.</param>
 127 /// <returns><c>true</c> in case of success, <c>false</c> in case of error.</returns>
 128 bool DelSignalCallback(System.String emission, System.String source, EflLayoutSignalCb func);
 129     /// <summary>Sends/emits an Edje signal to this layout.
 130 /// 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.
 131 ///
 132 /// See also the Edje Data Collection Reference for EDC files.
 133 ///
 134 /// See <see cref="Efl.Layout.ISignal.AddSignalCallback"/> for more on Edje signals.
 135 /// (Since EFL 1.22)</summary>
 136 /// <param name="emission">The signal&apos;s &quot;emission&quot; string</param>
 137 /// <param name="source">The signal&apos;s &quot;source&quot; string</param>
 138 void EmitSignal(System.String emission, System.String source);
 139     /// <summary>Processes an object&apos;s messages and signals queue.
 140 /// 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.
 141 ///
 142 /// If <c>recurse</c> is <c>true</c>, this function will be called recursively on all subobjects.
 143 /// (Since EFL 1.22)</summary>
 144 /// <param name="recurse">Whether to process messages on children objects.</param>
 145 void SignalProcess(bool recurse);
 146                     }
 147 /// <summary>Layouts asynchronous messaging and signaling interface.
 148 /// (Since EFL 1.22)</summary>
 149 sealed public class ISignalConcrete :
 150     Efl.Eo.EoWrapper
 151     , ISignal
 152
 153 {
 154     ///<summary>Pointer to the native class description.</summary>
 155     public override System.IntPtr NativeClass
 156     {
 157         get
 158         {
 159             if (((object)this).GetType() == typeof(ISignalConcrete))
 160             {
 161                 return GetEflClassStatic();
 162             }
 163             else
 164             {
 165                 return Efl.Eo.ClassRegister.klassFromType[((object)this).GetType()];
 166             }
 167         }
 168     }
 169
 170     [System.Runtime.InteropServices.DllImport(efl.Libs.Edje)] internal static extern System.IntPtr
 171         efl_layout_signal_interface_get();
 172     /// <summary>Initializes a new instance of the <see cref="ISignal"/> class.
 173     /// Internal usage: This is used when interacting with C code and should not be used directly.</summary>
 174     private ISignalConcrete(System.IntPtr raw) : base(raw)
 175     {
 176     }
 177
 178     /// <summary>Sends an (Edje) message to a given Edje object
 179     /// 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.
 180     ///
 181     /// Messages can go both ways, from code to theme, or theme to code.
 182     ///
 183     /// 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).
 184     /// (Since EFL 1.22)</summary>
 185     /// <param name="id">A identification number for the message to be sent</param>
 186     /// <param name="msg">The message&apos;s payload</param>
 187     public void MessageSend(int id, Eina.Value msg) {
 188                                                          Efl.Layout.ISignalConcrete.NativeMethods.efl_layout_signal_message_send_ptr.Value.Delegate(this.NativeHandle,id, msg);
 189         Eina.Error.RaiseIfUnhandledException();
 190                                          }
 191     /// <summary>Adds a callback for an arriving Edje signal, emitted by a given Edje object.
 192     /// 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
 193     ///
 194     /// Signals can go both ways, from code to theme, or theme to code.
 195     ///
 196     /// Though there are those common uses for the two strings, one is free to use them however they like.
 197     ///
 198     /// 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.
 199     ///
 200     /// 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.
 201     ///
 202     /// 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.
 203     ///
 204     /// See also the Edje Data Collection Reference for EDC files.
 205     ///
 206     /// 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"/>.
 207     /// (Since EFL 1.22)</summary>
 208     /// <param name="emission">The signal&apos;s &quot;emission&quot; string</param>
 209     /// <param name="source">The signal&apos;s &quot;source&quot; string</param>
 210     /// <param name="func">The callback function to be executed when the signal is emitted.</param>
 211     /// <returns><c>true</c> in case of success, <c>false</c> in case of error.</returns>
 212     public bool AddSignalCallback(System.String emission, System.String source, EflLayoutSignalCb func) {
 213                                                                          GCHandle func_handle = GCHandle.Alloc(func);
 214         var _ret_var = Efl.Layout.ISignalConcrete.NativeMethods.efl_layout_signal_callback_add_ptr.Value.Delegate(this.NativeHandle,emission, source, GCHandle.ToIntPtr(func_handle), EflLayoutSignalCbWrapper.Cb, Efl.Eo.Globals.free_gchandle);
 215         Eina.Error.RaiseIfUnhandledException();
 216                                                         return _ret_var;
 217  }
 218     /// <summary>Removes a signal-triggered callback from an object.
 219     /// 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"/>.
 220     ///
 221     /// See <see cref="Efl.Layout.ISignal.AddSignalCallback"/>.
 222     /// (Since EFL 1.22)</summary>
 223     /// <param name="emission">The signal&apos;s &quot;emission&quot; string</param>
 224     /// <param name="source">The signal&apos;s &quot;source&quot; string</param>
 225     /// <param name="func">The callback function to be executed when the signal is emitted.</param>
 226     /// <returns><c>true</c> in case of success, <c>false</c> in case of error.</returns>
 227     public bool DelSignalCallback(System.String emission, System.String source, EflLayoutSignalCb func) {
 228                                                                          GCHandle func_handle = GCHandle.Alloc(func);
 229         var _ret_var = Efl.Layout.ISignalConcrete.NativeMethods.efl_layout_signal_callback_del_ptr.Value.Delegate(this.NativeHandle,emission, source, GCHandle.ToIntPtr(func_handle), EflLayoutSignalCbWrapper.Cb, Efl.Eo.Globals.free_gchandle);
 230         Eina.Error.RaiseIfUnhandledException();
 231                                                         return _ret_var;
 232  }
 233     /// <summary>Sends/emits an Edje signal to this layout.
 234     /// 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.
 235     ///
 236     /// See also the Edje Data Collection Reference for EDC files.
 237     ///
 238     /// See <see cref="Efl.Layout.ISignal.AddSignalCallback"/> for more on Edje signals.
 239     /// (Since EFL 1.22)</summary>
 240     /// <param name="emission">The signal&apos;s &quot;emission&quot; string</param>
 241     /// <param name="source">The signal&apos;s &quot;source&quot; string</param>
 242     public void EmitSignal(System.String emission, System.String source) {
 243                                                          Efl.Layout.ISignalConcrete.NativeMethods.efl_layout_signal_emit_ptr.Value.Delegate(this.NativeHandle,emission, source);
 244         Eina.Error.RaiseIfUnhandledException();
 245                                          }
 246     /// <summary>Processes an object&apos;s messages and signals queue.
 247     /// 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.
 248     ///
 249     /// If <c>recurse</c> is <c>true</c>, this function will be called recursively on all subobjects.
 250     /// (Since EFL 1.22)</summary>
 251     /// <param name="recurse">Whether to process messages on children objects.</param>
 252     public void SignalProcess(bool recurse) {
 253                                  Efl.Layout.ISignalConcrete.NativeMethods.efl_layout_signal_process_ptr.Value.Delegate(this.NativeHandle,recurse);
 254         Eina.Error.RaiseIfUnhandledException();
 255                          }
 256     private static IntPtr GetEflClassStatic()
 257     {
 258         return Efl.Layout.ISignalConcrete.efl_layout_signal_interface_get();
 259     }
 260     /// <summary>Wrapper for native methods and virtual method delegates.
 261     /// For internal use by generated code only.</summary>
 262     public class NativeMethods  : Efl.Eo.NativeClass
 263     {
 264         private static Efl.Eo.NativeModule Module = new Efl.Eo.NativeModule(    efl.Libs.Edje);
 265         /// <summary>Gets the list of Eo operations to override.</summary>
 266         /// <returns>The list of Eo operations to be overload.</returns>
 267         public override System.Collections.Generic.List<Efl_Op_Description> GetEoOps(System.Type type)
 268         {
 269             var descs = new System.Collections.Generic.List<Efl_Op_Description>();
 270             var methods = Efl.Eo.Globals.GetUserMethods(type);
 271
 272             if (efl_layout_signal_message_send_static_delegate == null)
 273             {
 274                 efl_layout_signal_message_send_static_delegate = new efl_layout_signal_message_send_delegate(message_send);
 275             }
 276
 277             if (methods.FirstOrDefault(m => m.Name == "MessageSend") != null)
 278             {
 279                 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) });
 280             }
 281
 282             if (efl_layout_signal_callback_add_static_delegate == null)
 283             {
 284                 efl_layout_signal_callback_add_static_delegate = new efl_layout_signal_callback_add_delegate(signal_callback_add);
 285             }
 286
 287             if (methods.FirstOrDefault(m => m.Name == "AddSignalCallback") != null)
 288             {
 289                 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) });
 290             }
 291
 292             if (efl_layout_signal_callback_del_static_delegate == null)
 293             {
 294                 efl_layout_signal_callback_del_static_delegate = new efl_layout_signal_callback_del_delegate(signal_callback_del);
 295             }
 296
 297             if (methods.FirstOrDefault(m => m.Name == "DelSignalCallback") != null)
 298             {
 299                 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) });
 300             }
 301
 302             if (efl_layout_signal_emit_static_delegate == null)
 303             {
 304                 efl_layout_signal_emit_static_delegate = new efl_layout_signal_emit_delegate(signal_emit);
 305             }
 306
 307             if (methods.FirstOrDefault(m => m.Name == "EmitSignal") != null)
 308             {
 309                 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) });
 310             }
 311
 312             if (efl_layout_signal_process_static_delegate == null)
 313             {
 314                 efl_layout_signal_process_static_delegate = new efl_layout_signal_process_delegate(signal_process);
 315             }
 316
 317             if (methods.FirstOrDefault(m => m.Name == "SignalProcess") != null)
 318             {
 319                 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) });
 320             }
 321
 322             return descs;
 323         }
 324         /// <summary>Returns the Eo class for the native methods of this class.</summary>
 325         /// <returns>The native class pointer.</returns>
 326         public override IntPtr GetEflClass()
 327         {
 328             return Efl.Layout.ISignalConcrete.efl_layout_signal_interface_get();
 329         }
 330
 331         #pragma warning disable CA1707, CS1591, SA1300, SA1600
 332
 333
 334         private delegate void efl_layout_signal_message_send_delegate(System.IntPtr obj, System.IntPtr pd,  int id,  Eina.ValueNative msg);
 335
 336
 337         public delegate void efl_layout_signal_message_send_api_delegate(System.IntPtr obj,  int id,  Eina.ValueNative msg);
 338
 339         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");
 340
 341         private static void message_send(System.IntPtr obj, System.IntPtr pd, int id, Eina.ValueNative msg)
 342         {
 343             Eina.Log.Debug("function efl_layout_signal_message_send was called");
 344             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 345             if (ws != null)
 346             {
 347
 348                 try
 349                 {
 350                     ((ISignal)ws.Target).MessageSend(id, msg);
 351                 }
 352                 catch (Exception e)
 353                 {
 354                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 355                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 356                 }
 357
 358
 359             }
 360             else
 361             {
 362                 efl_layout_signal_message_send_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), id, msg);
 363             }
 364         }
 365
 366         private static efl_layout_signal_message_send_delegate efl_layout_signal_message_send_static_delegate;
 367
 368         [return: MarshalAs(UnmanagedType.U1)]
 369         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);
 370
 371         [return: MarshalAs(UnmanagedType.U1)]
 372         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);
 373
 374         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");
 375
 376         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)
 377         {
 378             Eina.Log.Debug("function efl_layout_signal_callback_add was called");
 379             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 380             if (ws != null)
 381             {
 382                                                                             EflLayoutSignalCbWrapper func_wrapper = new EflLayoutSignalCbWrapper(func, func_data, func_free_cb);
 383             bool _ret_var = default(bool);
 384                 try
 385                 {
 386                     _ret_var = ((ISignal)ws.Target).AddSignalCallback(emission, source, func_wrapper.ManagedCb);
 387                 }
 388                 catch (Exception e)
 389                 {
 390                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 391                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 392                 }
 393
 394                                                         return _ret_var;
 395
 396             }
 397             else
 398             {
 399                 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);
 400             }
 401         }
 402
 403         private static efl_layout_signal_callback_add_delegate efl_layout_signal_callback_add_static_delegate;
 404
 405         [return: MarshalAs(UnmanagedType.U1)]
 406         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);
 407
 408         [return: MarshalAs(UnmanagedType.U1)]
 409         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);
 410
 411         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");
 412
 413         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)
 414         {
 415             Eina.Log.Debug("function efl_layout_signal_callback_del was called");
 416             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 417             if (ws != null)
 418             {
 419                                                                             EflLayoutSignalCbWrapper func_wrapper = new EflLayoutSignalCbWrapper(func, func_data, func_free_cb);
 420             bool _ret_var = default(bool);
 421                 try
 422                 {
 423                     _ret_var = ((ISignal)ws.Target).DelSignalCallback(emission, source, func_wrapper.ManagedCb);
 424                 }
 425                 catch (Exception e)
 426                 {
 427                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 428                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 429                 }
 430
 431                                                         return _ret_var;
 432
 433             }
 434             else
 435             {
 436                 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);
 437             }
 438         }
 439
 440         private static efl_layout_signal_callback_del_delegate efl_layout_signal_callback_del_static_delegate;
 441
 442
 443         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);
 444
 445
 446         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);
 447
 448         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");
 449
 450         private static void signal_emit(System.IntPtr obj, System.IntPtr pd, System.String emission, System.String source)
 451         {
 452             Eina.Log.Debug("function efl_layout_signal_emit was called");
 453             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 454             if (ws != null)
 455             {
 456
 457                 try
 458                 {
 459                     ((ISignal)ws.Target).EmitSignal(emission, source);
 460                 }
 461                 catch (Exception e)
 462                 {
 463                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 464                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 465                 }
 466
 467
 468             }
 469             else
 470             {
 471                 efl_layout_signal_emit_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), emission, source);
 472             }
 473         }
 474
 475         private static efl_layout_signal_emit_delegate efl_layout_signal_emit_static_delegate;
 476
 477
 478         private delegate void efl_layout_signal_process_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.U1)] bool recurse);
 479
 480
 481         public delegate void efl_layout_signal_process_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.U1)] bool recurse);
 482
 483         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");
 484
 485         private static void signal_process(System.IntPtr obj, System.IntPtr pd, bool recurse)
 486         {
 487             Eina.Log.Debug("function efl_layout_signal_process was called");
 488             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 489             if (ws != null)
 490             {
 491
 492                 try
 493                 {
 494                     ((ISignal)ws.Target).SignalProcess(recurse);
 495                 }
 496                 catch (Exception e)
 497                 {
 498                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 499                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 500                 }
 501
 502
 503             }
 504             else
 505             {
 506                 efl_layout_signal_process_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), recurse);
 507             }
 508         }
 509
 510         private static efl_layout_signal_process_delegate efl_layout_signal_process_static_delegate;
 511
 512         #pragma warning restore CA1707, CS1591, SA1300, SA1600
 513
 514 }
 515 }
 516 }
 517
 518 }
 519