internals/src/EflSharp/EflSharp/efl/efl_layout_signal.eo.cs

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