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
 151 ISignal
 152
 153 {
 154     ///<summary>Pointer to the native class description.</summary>
 155     public 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     private  System.IntPtr handle;
 171     ///<summary>Pointer to the native instance.</summary>
 172     public System.IntPtr NativeHandle
 173     {
 174         get { return handle; }
 175     }
 176
 177     [System.Runtime.InteropServices.DllImport(efl.Libs.Edje)] internal static extern System.IntPtr
 178         efl_layout_signal_interface_get();
 179     /// <summary>Initializes a new instance of the <see cref="ISignal"/> class.
 180     /// Internal usage: This is used when interacting with C code and should not be used directly.</summary>
 181     private ISignalConcrete(System.IntPtr raw)
 182     {
 183         handle = raw;
 184     }
 185     ///<summary>Destructor.</summary>
 186     ~ISignalConcrete()
 187     {
 188         Dispose(false);
 189     }
 190
 191     ///<summary>Releases the underlying native instance.</summary>
 192     private void Dispose(bool disposing)
 193     {
 194         if (handle != System.IntPtr.Zero)
 195         {
 196             IntPtr h = handle;
 197             handle = IntPtr.Zero;
 198
 199             IntPtr gcHandlePtr = IntPtr.Zero;
 200             if (disposing)
 201             {
 202                 Efl.Eo.Globals.efl_mono_native_dispose(h, gcHandlePtr);
 203             }
 204             else
 205             {
 206                 Monitor.Enter(Efl.All.InitLock);
 207                 if (Efl.All.MainLoopInitialized)
 208                 {
 209                     Efl.Eo.Globals.efl_mono_thread_safe_native_dispose(h, gcHandlePtr);
 210                 }
 211
 212                 Monitor.Exit(Efl.All.InitLock);
 213             }
 214         }
 215
 216     }
 217
 218     ///<summary>Releases the underlying native instance.</summary>
 219     public void Dispose()
 220     {
 221         Dispose(true);
 222         GC.SuppressFinalize(this);
 223     }
 224
 225     /// <summary>Verifies if the given object is equal to this one.</summary>
 226     /// <param name="instance">The object to compare to.</param>
 227     /// <returns>True if both objects point to the same native object.</returns>
 228     public override bool Equals(object instance)
 229     {
 230         var other = instance as Efl.Object;
 231         if (other == null)
 232         {
 233             return false;
 234         }
 235         return this.NativeHandle == other.NativeHandle;
 236     }
 237
 238     /// <summary>Gets the hash code for this object based on the native pointer it points to.</summary>
 239     /// <returns>The value of the pointer, to be used as the hash code of this object.</returns>
 240     public override int GetHashCode()
 241     {
 242         return this.NativeHandle.ToInt32();
 243     }
 244
 245     /// <summary>Turns the native pointer into a string representation.</summary>
 246     /// <returns>A string with the type and the native pointer for this object.</returns>
 247     public override String ToString()
 248     {
 249         return $"{this.GetType().Name}@[{this.NativeHandle.ToInt32():x}]";
 250     }
 251
 252     /// <summary>Sends an (Edje) message to a given Edje object
 253     /// 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.
 254     ///
 255     /// Messages can go both ways, from code to theme, or theme to code.
 256     ///
 257     /// 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).
 258     /// (Since EFL 1.22)</summary>
 259     /// <param name="id">A identification number for the message to be sent</param>
 260     /// <param name="msg">The message&apos;s payload</param>
 261     public void MessageSend(int id, Eina.Value msg) {
 262                                                          Efl.Layout.ISignalConcrete.NativeMethods.efl_layout_signal_message_send_ptr.Value.Delegate(this.NativeHandle,id, msg);
 263         Eina.Error.RaiseIfUnhandledException();
 264                                          }
 265     /// <summary>Adds a callback for an arriving Edje signal, emitted by a given Edje object.
 266     /// 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
 267     ///
 268     /// Signals can go both ways, from code to theme, or theme to code.
 269     ///
 270     /// Though there are those common uses for the two strings, one is free to use them however they like.
 271     ///
 272     /// 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.
 273     ///
 274     /// 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.
 275     ///
 276     /// 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.
 277     ///
 278     /// See also the Edje Data Collection Reference for EDC files.
 279     ///
 280     /// 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"/>.
 281     /// (Since EFL 1.22)</summary>
 282     /// <param name="emission">The signal&apos;s &quot;emission&quot; string</param>
 283     /// <param name="source">The signal&apos;s &quot;source&quot; string</param>
 284     /// <param name="func">The callback function to be executed when the signal is emitted.</param>
 285     /// <returns><c>true</c> in case of success, <c>false</c> in case of error.</returns>
 286     public bool AddSignalCallback(System.String emission, System.String source, EflLayoutSignalCb func) {
 287                                                                          GCHandle func_handle = GCHandle.Alloc(func);
 288         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);
 289         Eina.Error.RaiseIfUnhandledException();
 290                                                         return _ret_var;
 291  }
 292     /// <summary>Removes a signal-triggered callback from an object.
 293     /// 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"/>.
 294     ///
 295     /// See <see cref="Efl.Layout.ISignal.AddSignalCallback"/>.
 296     /// (Since EFL 1.22)</summary>
 297     /// <param name="emission">The signal&apos;s &quot;emission&quot; string</param>
 298     /// <param name="source">The signal&apos;s &quot;source&quot; string</param>
 299     /// <param name="func">The callback function to be executed when the signal is emitted.</param>
 300     /// <returns><c>true</c> in case of success, <c>false</c> in case of error.</returns>
 301     public bool DelSignalCallback(System.String emission, System.String source, EflLayoutSignalCb func) {
 302                                                                          GCHandle func_handle = GCHandle.Alloc(func);
 303         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);
 304         Eina.Error.RaiseIfUnhandledException();
 305                                                         return _ret_var;
 306  }
 307     /// <summary>Sends/emits an Edje signal to this layout.
 308     /// 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.
 309     ///
 310     /// See also the Edje Data Collection Reference for EDC files.
 311     ///
 312     /// See <see cref="Efl.Layout.ISignal.AddSignalCallback"/> for more on Edje signals.
 313     /// (Since EFL 1.22)</summary>
 314     /// <param name="emission">The signal&apos;s &quot;emission&quot; string</param>
 315     /// <param name="source">The signal&apos;s &quot;source&quot; string</param>
 316     public void EmitSignal(System.String emission, System.String source) {
 317                                                          Efl.Layout.ISignalConcrete.NativeMethods.efl_layout_signal_emit_ptr.Value.Delegate(this.NativeHandle,emission, source);
 318         Eina.Error.RaiseIfUnhandledException();
 319                                          }
 320     /// <summary>Processes an object&apos;s messages and signals queue.
 321     /// 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.
 322     ///
 323     /// If <c>recurse</c> is <c>true</c>, this function will be called recursively on all subobjects.
 324     /// (Since EFL 1.22)</summary>
 325     /// <param name="recurse">Whether to process messages on children objects.</param>
 326     public void SignalProcess(bool recurse) {
 327                                  Efl.Layout.ISignalConcrete.NativeMethods.efl_layout_signal_process_ptr.Value.Delegate(this.NativeHandle,recurse);
 328         Eina.Error.RaiseIfUnhandledException();
 329                          }
 330     private static IntPtr GetEflClassStatic()
 331     {
 332         return Efl.Layout.ISignalConcrete.efl_layout_signal_interface_get();
 333     }
 334     /// <summary>Wrapper for native methods and virtual method delegates.
 335     /// For internal use by generated code only.</summary>
 336     public class NativeMethods  : Efl.Eo.NativeClass
 337     {
 338         private static Efl.Eo.NativeModule Module = new Efl.Eo.NativeModule(    efl.Libs.Edje);
 339         /// <summary>Gets the list of Eo operations to override.</summary>
 340         /// <returns>The list of Eo operations to be overload.</returns>
 341         public override System.Collections.Generic.List<Efl_Op_Description> GetEoOps(System.Type type)
 342         {
 343             var descs = new System.Collections.Generic.List<Efl_Op_Description>();
 344             var methods = Efl.Eo.Globals.GetUserMethods(type);
 345
 346             if (efl_layout_signal_message_send_static_delegate == null)
 347             {
 348                 efl_layout_signal_message_send_static_delegate = new efl_layout_signal_message_send_delegate(message_send);
 349             }
 350
 351             if (methods.FirstOrDefault(m => m.Name == "MessageSend") != null)
 352             {
 353                 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) });
 354             }
 355
 356             if (efl_layout_signal_callback_add_static_delegate == null)
 357             {
 358                 efl_layout_signal_callback_add_static_delegate = new efl_layout_signal_callback_add_delegate(signal_callback_add);
 359             }
 360
 361             if (methods.FirstOrDefault(m => m.Name == "AddSignalCallback") != null)
 362             {
 363                 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) });
 364             }
 365
 366             if (efl_layout_signal_callback_del_static_delegate == null)
 367             {
 368                 efl_layout_signal_callback_del_static_delegate = new efl_layout_signal_callback_del_delegate(signal_callback_del);
 369             }
 370
 371             if (methods.FirstOrDefault(m => m.Name == "DelSignalCallback") != null)
 372             {
 373                 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) });
 374             }
 375
 376             if (efl_layout_signal_emit_static_delegate == null)
 377             {
 378                 efl_layout_signal_emit_static_delegate = new efl_layout_signal_emit_delegate(signal_emit);
 379             }
 380
 381             if (methods.FirstOrDefault(m => m.Name == "EmitSignal") != null)
 382             {
 383                 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) });
 384             }
 385
 386             if (efl_layout_signal_process_static_delegate == null)
 387             {
 388                 efl_layout_signal_process_static_delegate = new efl_layout_signal_process_delegate(signal_process);
 389             }
 390
 391             if (methods.FirstOrDefault(m => m.Name == "SignalProcess") != null)
 392             {
 393                 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) });
 394             }
 395
 396             return descs;
 397         }
 398         /// <summary>Returns the Eo class for the native methods of this class.</summary>
 399         /// <returns>The native class pointer.</returns>
 400         public override IntPtr GetEflClass()
 401         {
 402             return Efl.Layout.ISignalConcrete.efl_layout_signal_interface_get();
 403         }
 404
 405         #pragma warning disable CA1707, SA1300, SA1600
 406
 407
 408         private delegate void efl_layout_signal_message_send_delegate(System.IntPtr obj, System.IntPtr pd,  int id,  Eina.ValueNative msg);
 409
 410
 411         public delegate void efl_layout_signal_message_send_api_delegate(System.IntPtr obj,  int id,  Eina.ValueNative msg);
 412
 413         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");
 414
 415         private static void message_send(System.IntPtr obj, System.IntPtr pd, int id, Eina.ValueNative msg)
 416         {
 417             Eina.Log.Debug("function efl_layout_signal_message_send was called");
 418             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
 419             if (wrapper != null)
 420             {
 421
 422                 try
 423                 {
 424                     ((ISignal)wrapper).MessageSend(id, msg);
 425                 }
 426                 catch (Exception e)
 427                 {
 428                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 429                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 430                 }
 431
 432
 433             }
 434             else
 435             {
 436                 efl_layout_signal_message_send_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), id, msg);
 437             }
 438         }
 439
 440         private static efl_layout_signal_message_send_delegate efl_layout_signal_message_send_static_delegate;
 441
 442         [return: MarshalAs(UnmanagedType.U1)]
 443         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);
 444
 445         [return: MarshalAs(UnmanagedType.U1)]
 446         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);
 447
 448         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");
 449
 450         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)
 451         {
 452             Eina.Log.Debug("function efl_layout_signal_callback_add was called");
 453             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
 454             if (wrapper != null)
 455             {
 456                                                                             EflLayoutSignalCbWrapper func_wrapper = new EflLayoutSignalCbWrapper(func, func_data, func_free_cb);
 457             bool _ret_var = default(bool);
 458                 try
 459                 {
 460                     _ret_var = ((ISignal)wrapper).AddSignalCallback(emission, source, func_wrapper.ManagedCb);
 461                 }
 462                 catch (Exception e)
 463                 {
 464                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 465                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 466                 }
 467
 468                                                         return _ret_var;
 469
 470             }
 471             else
 472             {
 473                 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);
 474             }
 475         }
 476
 477         private static efl_layout_signal_callback_add_delegate efl_layout_signal_callback_add_static_delegate;
 478
 479         [return: MarshalAs(UnmanagedType.U1)]
 480         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);
 481
 482         [return: MarshalAs(UnmanagedType.U1)]
 483         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);
 484
 485         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");
 486
 487         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)
 488         {
 489             Eina.Log.Debug("function efl_layout_signal_callback_del was called");
 490             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
 491             if (wrapper != null)
 492             {
 493                                                                             EflLayoutSignalCbWrapper func_wrapper = new EflLayoutSignalCbWrapper(func, func_data, func_free_cb);
 494             bool _ret_var = default(bool);
 495                 try
 496                 {
 497                     _ret_var = ((ISignal)wrapper).DelSignalCallback(emission, source, func_wrapper.ManagedCb);
 498                 }
 499                 catch (Exception e)
 500                 {
 501                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 502                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 503                 }
 504
 505                                                         return _ret_var;
 506
 507             }
 508             else
 509             {
 510                 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);
 511             }
 512         }
 513
 514         private static efl_layout_signal_callback_del_delegate efl_layout_signal_callback_del_static_delegate;
 515
 516
 517         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);
 518
 519
 520         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);
 521
 522         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");
 523
 524         private static void signal_emit(System.IntPtr obj, System.IntPtr pd, System.String emission, System.String source)
 525         {
 526             Eina.Log.Debug("function efl_layout_signal_emit was called");
 527             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
 528             if (wrapper != null)
 529             {
 530
 531                 try
 532                 {
 533                     ((ISignal)wrapper).EmitSignal(emission, source);
 534                 }
 535                 catch (Exception e)
 536                 {
 537                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 538                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 539                 }
 540
 541
 542             }
 543             else
 544             {
 545                 efl_layout_signal_emit_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), emission, source);
 546             }
 547         }
 548
 549         private static efl_layout_signal_emit_delegate efl_layout_signal_emit_static_delegate;
 550
 551
 552         private delegate void efl_layout_signal_process_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.U1)] bool recurse);
 553
 554
 555         public delegate void efl_layout_signal_process_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.U1)] bool recurse);
 556
 557         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");
 558
 559         private static void signal_process(System.IntPtr obj, System.IntPtr pd, bool recurse)
 560         {
 561             Eina.Log.Debug("function efl_layout_signal_process was called");
 562             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
 563             if (wrapper != null)
 564             {
 565
 566                 try
 567                 {
 568                     ((ISignal)wrapper).SignalProcess(recurse);
 569                 }
 570                 catch (Exception e)
 571                 {
 572                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 573                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 574                 }
 575
 576
 577             }
 578             else
 579             {
 580                 efl_layout_signal_process_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), recurse);
 581             }
 582         }
 583
 584         private static efl_layout_signal_process_delegate efl_layout_signal_process_static_delegate;
 585
 586         #pragma warning restore CA1707, SA1300, SA1600
 587
 588 }
 589 }
 590 }
 591
 592 }
 593