internals/src/EflSharp/EflSharp/efl/efl_loop_message_future_handler.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.ComponentModel;
   7 namespace Efl {
   8 ///<summary>Event argument wrapper for event <see cref="Efl.LoopMessageFutureHandler.MessageFutureEvt"/>.</summary>
   9 public class LoopMessageFutureHandlerMessageFutureEvt_Args : EventArgs {
  10     ///<summary>Actual event payload.</summary>
  11     public Efl.LoopMessageFuture arg { get; set; }
  12 }
  13 /// <summary>Internal use for future on an efl loop - replacing legacy ecore events</summary>
  14 [LoopMessageFutureHandlerNativeInherit]
  15 public class LoopMessageFutureHandler : Efl.LoopMessageHandler, Efl.Eo.IWrapper
  16 {
  17     ///<summary>Pointer to the native class description.</summary>
  18     public override System.IntPtr NativeClass {
  19         get {
  20             if (((object)this).GetType() == typeof (LoopMessageFutureHandler))
  21                 return Efl.LoopMessageFutureHandlerNativeInherit.GetEflClassStatic();
  22             else
  23                 return Efl.Eo.ClassRegister.klassFromType[((object)this).GetType()];
  24         }
  25     }
  26     [System.Runtime.InteropServices.DllImport(efl.Libs.Ecore)] internal static extern System.IntPtr
  27         efl_loop_message_future_handler_class_get();
  28     ///<summary>Creates a new instance.</summary>
  29     ///<param name="parent">Parent instance.</param>
  30     public LoopMessageFutureHandler(Efl.Object parent= null
  31             ) :
  32         base(efl_loop_message_future_handler_class_get(), typeof(LoopMessageFutureHandler), parent)
  33     {
  34         FinishInstantiation();
  35     }
  36     ///<summary>Internal usage: Constructs an instance from a native pointer. This is used when interacting with C code and should not be used directly.</summary>
  37     protected LoopMessageFutureHandler(System.IntPtr raw) : base(raw)
  38     {
  39                 RegisterEventProxies();
  40     }
  41     ///<summary>Internal usage: Constructor to forward the wrapper initialization to the root class that interfaces with native code. Should not be used directly.</summary>
  42     protected LoopMessageFutureHandler(IntPtr base_klass, System.Type managed_type, Efl.Object parent) : base(base_klass, managed_type, parent) {}
  43     ///<summary>Verifies if the given object is equal to this one.</summary>
  44     public override bool Equals(object obj)
  45     {
  46         var other = obj as Efl.Object;
  47         if (other == null)
  48             return false;
  49         return this.NativeHandle == other.NativeHandle;
  50     }
  51     ///<summary>Gets the hash code for this object based on the native pointer it points to.</summary>
  52     public override int GetHashCode()
  53     {
  54         return this.NativeHandle.ToInt32();
  55     }
  56     ///<summary>Turns the native pointer into a string representation.</summary>
  57     public override String ToString()
  58     {
  59         return $"{this.GetType().Name}@[{this.NativeHandle.ToInt32():x}]";
  60     }
  61 private static object MessageFutureEvtKey = new object();
  62     /// <summary>No description supplied.</summary>
  63     public event EventHandler<Efl.LoopMessageFutureHandlerMessageFutureEvt_Args> MessageFutureEvt
  64     {
  65         add {
  66             lock (eventLock) {
  67                 string key = "_EFL_LOOP_MESSAGE_FUTURE_HANDLER_EVENT_MESSAGE_FUTURE";
  68                 if (AddNativeEventHandler(efl.Libs.Ecore, key, this.evt_MessageFutureEvt_delegate)) {
  69                     eventHandlers.AddHandler(MessageFutureEvtKey , value);
  70                 } else
  71                     Eina.Log.Error($"Error adding proxy for event {key}");
  72             }
  73         }
  74         remove {
  75             lock (eventLock) {
  76                 string key = "_EFL_LOOP_MESSAGE_FUTURE_HANDLER_EVENT_MESSAGE_FUTURE";
  77                 if (RemoveNativeEventHandler(key, this.evt_MessageFutureEvt_delegate)) {
  78                     eventHandlers.RemoveHandler(MessageFutureEvtKey , value);
  79                 } else
  80                     Eina.Log.Error($"Error removing proxy for event {key}");
  81             }
  82         }
  83     }
  84     ///<summary>Method to raise event MessageFutureEvt.</summary>
  85     public void On_MessageFutureEvt(Efl.LoopMessageFutureHandlerMessageFutureEvt_Args e)
  86     {
  87         EventHandler<Efl.LoopMessageFutureHandlerMessageFutureEvt_Args> evt;
  88         lock (eventLock) {
  89         evt = (EventHandler<Efl.LoopMessageFutureHandlerMessageFutureEvt_Args>)eventHandlers[MessageFutureEvtKey];
  90         }
  91         evt?.Invoke(this, e);
  92     }
  93     Efl.EventCb evt_MessageFutureEvt_delegate;
  94     private void on_MessageFutureEvt_NativeCallback(System.IntPtr data, ref Efl.Event.NativeStruct evt)
  95     {
  96         Efl.LoopMessageFutureHandlerMessageFutureEvt_Args args = new Efl.LoopMessageFutureHandlerMessageFutureEvt_Args();
  97       args.arg = (Efl.Eo.Globals.CreateWrapperFor(evt.Info) as Efl.LoopMessageFuture);
  98         try {
  99             On_MessageFutureEvt(args);
 100         } catch (Exception e) {
 101             Eina.Log.Error(e.ToString());
 102             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 103         }
 104     }
 105
 106     ///<summary>Register the Eo event wrappers making the bridge to C# events. Internal usage only.</summary>
 107     protected override void RegisterEventProxies()
 108     {
 109         base.RegisterEventProxies();
 110         evt_MessageFutureEvt_delegate = new Efl.EventCb(on_MessageFutureEvt_NativeCallback);
 111     }
 112     /// <summary>No description supplied.</summary>
 113     /// <returns>No description supplied.</returns>
 114     virtual public Efl.LoopMessageFuture AddMessageType() {
 115          var _ret_var = Efl.LoopMessageFutureHandlerNativeInherit.efl_loop_message_future_handler_message_type_add_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 116         Eina.Error.RaiseIfUnhandledException();
 117         return _ret_var;
 118  }
 119     private static IntPtr GetEflClassStatic()
 120     {
 121         return Efl.LoopMessageFutureHandler.efl_loop_message_future_handler_class_get();
 122     }
 123 }
 124 public class LoopMessageFutureHandlerNativeInherit : Efl.LoopMessageHandlerNativeInherit{
 125     public new  static Efl.Eo.NativeModule _Module = new Efl.Eo.NativeModule(efl.Libs.Ecore);
 126     public override System.Collections.Generic.List<Efl_Op_Description> GetEoOps(System.Type type)
 127     {
 128         var descs = new System.Collections.Generic.List<Efl_Op_Description>();
 129         var methods = Efl.Eo.Globals.GetUserMethods(type);
 130         if (efl_loop_message_future_handler_message_type_add_static_delegate == null)
 131             efl_loop_message_future_handler_message_type_add_static_delegate = new efl_loop_message_future_handler_message_type_add_delegate(message_type_add);
 132         if (methods.FirstOrDefault(m => m.Name == "AddMessageType") != null)
 133             descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_loop_message_future_handler_message_type_add"), func = Marshal.GetFunctionPointerForDelegate(efl_loop_message_future_handler_message_type_add_static_delegate)});
 134         descs.AddRange(base.GetEoOps(type));
 135         return descs;
 136     }
 137     public override IntPtr GetEflClass()
 138     {
 139         return Efl.LoopMessageFutureHandler.efl_loop_message_future_handler_class_get();
 140     }
 141     public static new  IntPtr GetEflClassStatic()
 142     {
 143         return Efl.LoopMessageFutureHandler.efl_loop_message_future_handler_class_get();
 144     }
 145
 146
 147     [return:MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalTest<Efl.LoopMessageFuture, Efl.Eo.NonOwnTag>))] private delegate Efl.LoopMessageFuture efl_loop_message_future_handler_message_type_add_delegate(System.IntPtr obj, System.IntPtr pd);
 148
 149
 150     [return:MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalTest<Efl.LoopMessageFuture, Efl.Eo.NonOwnTag>))] public delegate Efl.LoopMessageFuture efl_loop_message_future_handler_message_type_add_api_delegate(System.IntPtr obj);
 151      public static Efl.Eo.FunctionWrapper<efl_loop_message_future_handler_message_type_add_api_delegate> efl_loop_message_future_handler_message_type_add_ptr = new Efl.Eo.FunctionWrapper<efl_loop_message_future_handler_message_type_add_api_delegate>(_Module, "efl_loop_message_future_handler_message_type_add");
 152      private static Efl.LoopMessageFuture message_type_add(System.IntPtr obj, System.IntPtr pd)
 153     {
 154         Eina.Log.Debug("function efl_loop_message_future_handler_message_type_add was called");
 155         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
 156         if(wrapper != null) {
 157                         Efl.LoopMessageFuture _ret_var = default(Efl.LoopMessageFuture);
 158             try {
 159                 _ret_var = ((LoopMessageFutureHandler)wrapper).AddMessageType();
 160             } catch (Exception e) {
 161                 Eina.Log.Warning($"Callback error: {e.ToString()}");
 162                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 163             }
 164         return _ret_var;
 165         } else {
 166             return efl_loop_message_future_handler_message_type_add_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
 167         }
 168     }
 169     private static efl_loop_message_future_handler_message_type_add_delegate efl_loop_message_future_handler_message_type_add_static_delegate;
 170 }
 171 }