internals/src/EflSharp/EflSharp/efl/efl_loop_message_handler.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 namespace Efl {
  10
  11 /// <summary>Event argument wrapper for event <see cref="Efl.LoopMessageHandler.MessageEvt"/>.</summary>
  12 [Efl.Eo.BindingEntity]
  13 public class LoopMessageHandlerMessageEvt_Args : EventArgs {
  14     /// <summary>Actual event payload.</summary>
  15     /// <value>The message payload data</value>
  16     public Efl.LoopMessage arg { get; set; }
  17 }
  18 /// <summary>Message handlers represent a single message type on the Efl.Loop parent object. These message handlers can be used to listen for that message type by listening to the message event for the generic case or a class specific event type to get specific message object typing correct.</summary>
  19 /// <remarks>This is a <b>BETA</b> class. It can be modified or removed in the future. Do not use it for product development.</remarks>
  20 [Efl.LoopMessageHandler.NativeMethods]
  21 [Efl.Eo.BindingEntity]
  22 public class LoopMessageHandler : Efl.Object
  23 {
  24     /// <summary>Pointer to the native class description.</summary>
  25     public override System.IntPtr NativeClass
  26     {
  27         get
  28         {
  29             if (((object)this).GetType() == typeof(LoopMessageHandler))
  30             {
  31                 return GetEflClassStatic();
  32             }
  33             else
  34             {
  35                 return Efl.Eo.ClassRegister.klassFromType[((object)this).GetType()];
  36             }
  37         }
  38     }
  39
  40     [System.Runtime.InteropServices.DllImport(efl.Libs.Ecore)] internal static extern System.IntPtr
  41         efl_loop_message_handler_class_get();
  42     /// <summary>Initializes a new instance of the <see cref="LoopMessageHandler"/> class.</summary>
  43     /// <param name="parent">Parent instance.</param>
  44     public LoopMessageHandler(Efl.Object parent= null
  45             ) : base(efl_loop_message_handler_class_get(), parent)
  46     {
  47         FinishInstantiation();
  48     }
  49
  50     /// <summary>Subclasses should override this constructor if they are expected to be instantiated from native code.
  51     /// Do not call this constructor directly.</summary>
  52     /// <param name="ch">Tag struct storing the native handle of the object being constructed.</param>
  53     protected LoopMessageHandler(ConstructingHandle ch) : base(ch)
  54     {
  55     }
  56
  57     /// <summary>Initializes a new instance of the <see cref="LoopMessageHandler"/> class.
  58     /// Internal usage: Constructs an instance from a native pointer. This is used when interacting with C code and should not be used directly.</summary>
  59     /// <param name="wh">The native pointer to be wrapped.</param>
  60     protected LoopMessageHandler(Efl.Eo.Globals.WrappingHandle wh) : base(wh)
  61     {
  62     }
  63
  64     /// <summary>Initializes a new instance of the <see cref="LoopMessageHandler"/> class.
  65     /// Internal usage: Constructor to forward the wrapper initialization to the root class that interfaces with native code. Should not be used directly.</summary>
  66     /// <param name="baseKlass">The pointer to the base native Eo class.</param>
  67     /// <param name="parent">The Efl.Object parent of this instance.</param>
  68     protected LoopMessageHandler(IntPtr baseKlass, Efl.Object parent) : base(baseKlass, parent)
  69     {
  70     }
  71
  72     /// <summary>The message payload data</summary>
  73     /// <value><see cref="Efl.LoopMessageHandlerMessageEvt_Args"/></value>
  74     public event EventHandler<Efl.LoopMessageHandlerMessageEvt_Args> MessageEvt
  75     {
  76         add
  77         {
  78             lock (eflBindingEventLock)
  79             {
  80                 Efl.EventCb callerCb = (IntPtr data, ref Efl.Event.NativeStruct evt) =>
  81                 {
  82                     var obj = Efl.Eo.Globals.WrapperSupervisorPtrToManaged(data).Target;
  83                     if (obj != null)
  84                     {
  85                         Efl.LoopMessageHandlerMessageEvt_Args args = new Efl.LoopMessageHandlerMessageEvt_Args();
  86                         args.arg = (Efl.Eo.Globals.CreateWrapperFor(evt.Info) as Efl.LoopMessage);
  87                         try
  88                         {
  89                             value?.Invoke(obj, args);
  90                         }
  91                         catch (Exception e)
  92                         {
  93                             Eina.Log.Error(e.ToString());
  94                             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
  95                         }
  96                     }
  97                 };
  98
  99                 string key = "_EFL_LOOP_MESSAGE_HANDLER_EVENT_MESSAGE";
 100                 AddNativeEventHandler(efl.Libs.Ecore, key, callerCb, value);
 101             }
 102         }
 103
 104         remove
 105         {
 106             lock (eflBindingEventLock)
 107             {
 108                 string key = "_EFL_LOOP_MESSAGE_HANDLER_EVENT_MESSAGE";
 109                 RemoveNativeEventHandler(efl.Libs.Ecore, key, value);
 110             }
 111         }
 112     }
 113     /// <summary>Method to raise event MessageEvt.</summary>
 114     public void OnMessageEvt(Efl.LoopMessageHandlerMessageEvt_Args e)
 115     {
 116         var key = "_EFL_LOOP_MESSAGE_HANDLER_EVENT_MESSAGE";
 117         IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Ecore, key);
 118         if (desc == IntPtr.Zero)
 119         {
 120             Eina.Log.Error($"Failed to get native event {key}");
 121             return;
 122         }
 123
 124         IntPtr info = e.arg.NativeHandle;
 125         Efl.Eo.Globals.efl_event_callback_call(this.NativeHandle, desc, info);
 126     }
 127     /// <summary>Creates a new message object of the correct type for this message type.</summary>
 128     /// <returns>The new message payload object.</returns>
 129     virtual public Efl.LoopMessage AddMessage() {
 130          var _ret_var = Efl.LoopMessageHandler.NativeMethods.efl_loop_message_handler_message_add_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)));
 131         Eina.Error.RaiseIfUnhandledException();
 132         return _ret_var;
 133  }
 134     /// <summary>Place the message on the queue to be called later when message_process() is called on the loop object.</summary>
 135     /// <param name="message">The message to place on the queue.</param>
 136     virtual public void MessageSend(Efl.LoopMessage message) {
 137                                  Efl.LoopMessageHandler.NativeMethods.efl_loop_message_handler_message_send_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)),message);
 138         Eina.Error.RaiseIfUnhandledException();
 139                          }
 140     /// <summary>Overide me (implement) then call super after calling the right callback type if you specialize the message type.</summary>
 141     /// <param name="message">Generic message event type</param>
 142     virtual public void CallMessage(Efl.LoopMessage message) {
 143                                  Efl.LoopMessageHandler.NativeMethods.efl_loop_message_handler_message_call_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)),message);
 144         Eina.Error.RaiseIfUnhandledException();
 145                          }
 146     /// <summary>Delete all queued messages belonging to this message handler that are pending on the queue so they are not processed later.</summary>
 147     /// <returns>True if any messages of this type were cleared.</returns>
 148     virtual public bool ClearMessage() {
 149          var _ret_var = Efl.LoopMessageHandler.NativeMethods.efl_loop_message_handler_message_clear_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)));
 150         Eina.Error.RaiseIfUnhandledException();
 151         return _ret_var;
 152  }
 153     private static IntPtr GetEflClassStatic()
 154     {
 155         return Efl.LoopMessageHandler.efl_loop_message_handler_class_get();
 156     }
 157     /// <summary>Wrapper for native methods and virtual method delegates.
 158     /// For internal use by generated code only.</summary>
 159     public new class NativeMethods : Efl.Object.NativeMethods
 160     {
 161         private static Efl.Eo.NativeModule Module = new Efl.Eo.NativeModule(    efl.Libs.Ecore);
 162         /// <summary>Gets the list of Eo operations to override.</summary>
 163         /// <returns>The list of Eo operations to be overload.</returns>
 164         public override System.Collections.Generic.List<Efl_Op_Description> GetEoOps(System.Type type)
 165         {
 166             var descs = new System.Collections.Generic.List<Efl_Op_Description>();
 167             var methods = Efl.Eo.Globals.GetUserMethods(type);
 168
 169             if (efl_loop_message_handler_message_add_static_delegate == null)
 170             {
 171                 efl_loop_message_handler_message_add_static_delegate = new efl_loop_message_handler_message_add_delegate(message_add);
 172             }
 173
 174             if (methods.FirstOrDefault(m => m.Name == "AddMessage") != null)
 175             {
 176                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_loop_message_handler_message_add"), func = Marshal.GetFunctionPointerForDelegate(efl_loop_message_handler_message_add_static_delegate) });
 177             }
 178
 179             if (efl_loop_message_handler_message_send_static_delegate == null)
 180             {
 181                 efl_loop_message_handler_message_send_static_delegate = new efl_loop_message_handler_message_send_delegate(message_send);
 182             }
 183
 184             if (methods.FirstOrDefault(m => m.Name == "MessageSend") != null)
 185             {
 186                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_loop_message_handler_message_send"), func = Marshal.GetFunctionPointerForDelegate(efl_loop_message_handler_message_send_static_delegate) });
 187             }
 188
 189             if (efl_loop_message_handler_message_call_static_delegate == null)
 190             {
 191                 efl_loop_message_handler_message_call_static_delegate = new efl_loop_message_handler_message_call_delegate(message_call);
 192             }
 193
 194             if (methods.FirstOrDefault(m => m.Name == "CallMessage") != null)
 195             {
 196                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_loop_message_handler_message_call"), func = Marshal.GetFunctionPointerForDelegate(efl_loop_message_handler_message_call_static_delegate) });
 197             }
 198
 199             if (efl_loop_message_handler_message_clear_static_delegate == null)
 200             {
 201                 efl_loop_message_handler_message_clear_static_delegate = new efl_loop_message_handler_message_clear_delegate(message_clear);
 202             }
 203
 204             if (methods.FirstOrDefault(m => m.Name == "ClearMessage") != null)
 205             {
 206                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_loop_message_handler_message_clear"), func = Marshal.GetFunctionPointerForDelegate(efl_loop_message_handler_message_clear_static_delegate) });
 207             }
 208
 209             descs.AddRange(base.GetEoOps(type));
 210             return descs;
 211         }
 212         /// <summary>Returns the Eo class for the native methods of this class.</summary>
 213         /// <returns>The native class pointer.</returns>
 214         public override IntPtr GetEflClass()
 215         {
 216             return Efl.LoopMessageHandler.efl_loop_message_handler_class_get();
 217         }
 218
 219         #pragma warning disable CA1707, CS1591, SA1300, SA1600
 220
 221         [return:MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))]
 222         private delegate Efl.LoopMessage efl_loop_message_handler_message_add_delegate(System.IntPtr obj, System.IntPtr pd);
 223
 224         [return:MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))]
 225         public delegate Efl.LoopMessage efl_loop_message_handler_message_add_api_delegate(System.IntPtr obj);
 226
 227         public static Efl.Eo.FunctionWrapper<efl_loop_message_handler_message_add_api_delegate> efl_loop_message_handler_message_add_ptr = new Efl.Eo.FunctionWrapper<efl_loop_message_handler_message_add_api_delegate>(Module, "efl_loop_message_handler_message_add");
 228
 229         private static Efl.LoopMessage message_add(System.IntPtr obj, System.IntPtr pd)
 230         {
 231             Eina.Log.Debug("function efl_loop_message_handler_message_add was called");
 232             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 233             if (ws != null)
 234             {
 235             Efl.LoopMessage _ret_var = default(Efl.LoopMessage);
 236                 try
 237                 {
 238                     _ret_var = ((LoopMessageHandler)ws.Target).AddMessage();
 239                 }
 240                 catch (Exception e)
 241                 {
 242                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 243                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 244                 }
 245
 246         return _ret_var;
 247
 248             }
 249             else
 250             {
 251                 return efl_loop_message_handler_message_add_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
 252             }
 253         }
 254
 255         private static efl_loop_message_handler_message_add_delegate efl_loop_message_handler_message_add_static_delegate;
 256
 257
 258         private delegate void efl_loop_message_handler_message_send_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))] Efl.LoopMessage message);
 259
 260
 261         public delegate void efl_loop_message_handler_message_send_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))] Efl.LoopMessage message);
 262
 263         public static Efl.Eo.FunctionWrapper<efl_loop_message_handler_message_send_api_delegate> efl_loop_message_handler_message_send_ptr = new Efl.Eo.FunctionWrapper<efl_loop_message_handler_message_send_api_delegate>(Module, "efl_loop_message_handler_message_send");
 264
 265         private static void message_send(System.IntPtr obj, System.IntPtr pd, Efl.LoopMessage message)
 266         {
 267             Eina.Log.Debug("function efl_loop_message_handler_message_send was called");
 268             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 269             if (ws != null)
 270             {
 271
 272                 try
 273                 {
 274                     ((LoopMessageHandler)ws.Target).MessageSend(message);
 275                 }
 276                 catch (Exception e)
 277                 {
 278                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 279                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 280                 }
 281
 282
 283             }
 284             else
 285             {
 286                 efl_loop_message_handler_message_send_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), message);
 287             }
 288         }
 289
 290         private static efl_loop_message_handler_message_send_delegate efl_loop_message_handler_message_send_static_delegate;
 291
 292
 293         private delegate void efl_loop_message_handler_message_call_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))] Efl.LoopMessage message);
 294
 295
 296         public delegate void efl_loop_message_handler_message_call_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))] Efl.LoopMessage message);
 297
 298         public static Efl.Eo.FunctionWrapper<efl_loop_message_handler_message_call_api_delegate> efl_loop_message_handler_message_call_ptr = new Efl.Eo.FunctionWrapper<efl_loop_message_handler_message_call_api_delegate>(Module, "efl_loop_message_handler_message_call");
 299
 300         private static void message_call(System.IntPtr obj, System.IntPtr pd, Efl.LoopMessage message)
 301         {
 302             Eina.Log.Debug("function efl_loop_message_handler_message_call was called");
 303             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 304             if (ws != null)
 305             {
 306
 307                 try
 308                 {
 309                     ((LoopMessageHandler)ws.Target).CallMessage(message);
 310                 }
 311                 catch (Exception e)
 312                 {
 313                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 314                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 315                 }
 316
 317
 318             }
 319             else
 320             {
 321                 efl_loop_message_handler_message_call_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), message);
 322             }
 323         }
 324
 325         private static efl_loop_message_handler_message_call_delegate efl_loop_message_handler_message_call_static_delegate;
 326
 327         [return: MarshalAs(UnmanagedType.U1)]
 328         private delegate bool efl_loop_message_handler_message_clear_delegate(System.IntPtr obj, System.IntPtr pd);
 329
 330         [return: MarshalAs(UnmanagedType.U1)]
 331         public delegate bool efl_loop_message_handler_message_clear_api_delegate(System.IntPtr obj);
 332
 333         public static Efl.Eo.FunctionWrapper<efl_loop_message_handler_message_clear_api_delegate> efl_loop_message_handler_message_clear_ptr = new Efl.Eo.FunctionWrapper<efl_loop_message_handler_message_clear_api_delegate>(Module, "efl_loop_message_handler_message_clear");
 334
 335         private static bool message_clear(System.IntPtr obj, System.IntPtr pd)
 336         {
 337             Eina.Log.Debug("function efl_loop_message_handler_message_clear was called");
 338             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 339             if (ws != null)
 340             {
 341             bool _ret_var = default(bool);
 342                 try
 343                 {
 344                     _ret_var = ((LoopMessageHandler)ws.Target).ClearMessage();
 345                 }
 346                 catch (Exception e)
 347                 {
 348                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 349                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 350                 }
 351
 352         return _ret_var;
 353
 354             }
 355             else
 356             {
 357                 return efl_loop_message_handler_message_clear_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
 358             }
 359         }
 360
 361         private static efl_loop_message_handler_message_clear_delegate efl_loop_message_handler_message_clear_static_delegate;
 362
 363         #pragma warning restore CA1707, CS1591, SA1300, SA1600
 364
 365 }
 366 }
 367 }
 368
 369 #if EFL_BETA
 370 #pragma warning disable CS1591
 371 public static class EflLoopMessageHandler_ExtensionMethods {
 372 }
 373 #pragma warning restore CS1591
 374 #endif