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