internals/src/EflSharp/EflSharp/efl/efl_threadio.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_event">No description supplied.</param>
   9 [Efl.Eo.BindingEntity]
  10 public delegate void EFlThreadIOCall(ref Efl.Event kw_event);
  11 public delegate void EFlThreadIOCallInternal(IntPtr data,  ref Efl.Event.NativeStruct kw_event);
  12 internal class EFlThreadIOCallWrapper : IDisposable
  13 {
  14
  15     private EFlThreadIOCallInternal _cb;
  16     private IntPtr _cb_data;
  17     private EinaFreeCb _cb_free_cb;
  18
  19     internal EFlThreadIOCallWrapper (EFlThreadIOCallInternal _cb, IntPtr _cb_data, EinaFreeCb _cb_free_cb)
  20     {
  21         this._cb = _cb;
  22         this._cb_data = _cb_data;
  23         this._cb_free_cb = _cb_free_cb;
  24     }
  25
  26     ~EFlThreadIOCallWrapper()
  27     {
  28         Dispose(false);
  29     }
  30
  31     protected virtual void Dispose(bool disposing)
  32     {
  33         if (this._cb_free_cb != null)
  34         {
  35             if (disposing)
  36             {
  37                 this._cb_free_cb(this._cb_data);
  38             }
  39             else
  40             {
  41                 Efl.Eo.Globals.ThreadSafeFreeCbExec(this._cb_free_cb, this._cb_data);
  42             }
  43             this._cb_free_cb = null;
  44             this._cb_data = IntPtr.Zero;
  45             this._cb = null;
  46         }
  47     }
  48
  49     public void Dispose()
  50     {
  51         Dispose(true);
  52         GC.SuppressFinalize(this);
  53     }
  54
  55     internal void ManagedCb(ref Efl.Event kw_event)
  56     {
  57         Efl.Event.NativeStruct _in_kw_event = kw_event;
  58                         _cb(_cb_data, ref _in_kw_event);
  59         Eina.Error.RaiseIfUnhandledException();
  60                 kw_event = _in_kw_event;
  61             }
  62
  63         internal static void Cb(IntPtr cb_data,  ref Efl.Event.NativeStruct kw_event)
  64     {
  65         GCHandle handle = GCHandle.FromIntPtr(cb_data);
  66         EFlThreadIOCall cb = (EFlThreadIOCall)handle.Target;
  67         Efl.Event _in_kw_event = kw_event;
  68
  69         try {
  70             cb(ref _in_kw_event);
  71         } catch (Exception e) {
  72             Eina.Log.Warning($"Callback error: {e.ToString()}");
  73             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
  74         }
  75                 kw_event = _in_kw_event;
  76             }
  77 }
  78
  79
  80 /// <param name="kw_event">No description supplied.</param>
  81 [Efl.Eo.BindingEntity]
  82 public delegate System.IntPtr EFlThreadIOCallSync(ref Efl.Event kw_event);
  83 public delegate System.IntPtr EFlThreadIOCallSyncInternal(IntPtr data,  ref Efl.Event.NativeStruct kw_event);
  84 internal class EFlThreadIOCallSyncWrapper : IDisposable
  85 {
  86
  87     private EFlThreadIOCallSyncInternal _cb;
  88     private IntPtr _cb_data;
  89     private EinaFreeCb _cb_free_cb;
  90
  91     internal EFlThreadIOCallSyncWrapper (EFlThreadIOCallSyncInternal _cb, IntPtr _cb_data, EinaFreeCb _cb_free_cb)
  92     {
  93         this._cb = _cb;
  94         this._cb_data = _cb_data;
  95         this._cb_free_cb = _cb_free_cb;
  96     }
  97
  98     ~EFlThreadIOCallSyncWrapper()
  99     {
 100         Dispose(false);
 101     }
 102
 103     protected virtual void Dispose(bool disposing)
 104     {
 105         if (this._cb_free_cb != null)
 106         {
 107             if (disposing)
 108             {
 109                 this._cb_free_cb(this._cb_data);
 110             }
 111             else
 112             {
 113                 Efl.Eo.Globals.ThreadSafeFreeCbExec(this._cb_free_cb, this._cb_data);
 114             }
 115             this._cb_free_cb = null;
 116             this._cb_data = IntPtr.Zero;
 117             this._cb = null;
 118         }
 119     }
 120
 121     public void Dispose()
 122     {
 123         Dispose(true);
 124         GC.SuppressFinalize(this);
 125     }
 126
 127     internal System.IntPtr ManagedCb(ref Efl.Event kw_event)
 128     {
 129         Efl.Event.NativeStruct _in_kw_event = kw_event;
 130                         var _ret_var = _cb(_cb_data, ref _in_kw_event);
 131         Eina.Error.RaiseIfUnhandledException();
 132                 kw_event = _in_kw_event;
 133         return _ret_var;
 134     }
 135
 136         internal static System.IntPtr Cb(IntPtr cb_data,  ref Efl.Event.NativeStruct kw_event)
 137     {
 138         GCHandle handle = GCHandle.FromIntPtr(cb_data);
 139         EFlThreadIOCallSync cb = (EFlThreadIOCallSync)handle.Target;
 140         Efl.Event _in_kw_event = kw_event;
 141                             System.IntPtr _ret_var = default(System.IntPtr);
 142         try {
 143             _ret_var = cb(ref _in_kw_event);
 144         } catch (Exception e) {
 145             Eina.Log.Warning($"Callback error: {e.ToString()}");
 146             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 147         }
 148                 kw_event = _in_kw_event;
 149         return _ret_var;
 150     }
 151 }
 152
 153
 154 namespace Efl {
 155
 156 /// <summary>No description supplied.</summary>
 157 [Efl.IThreadIOConcrete.NativeMethods]
 158 [Efl.Eo.BindingEntity]
 159 public interface IThreadIO :
 160     Efl.Eo.IWrapper, IDisposable
 161 {
 162     /// <returns>No description supplied.</returns>
 163 System.IntPtr GetIndata();
 164     /// <param name="data">No description supplied.</param>
 165 void SetIndata(System.IntPtr data);
 166     /// <returns>No description supplied.</returns>
 167 System.IntPtr GetOutdata();
 168     /// <param name="data">No description supplied.</param>
 169 void SetOutdata(System.IntPtr data);
 170     /// <param name="func">No description supplied.</param>
 171 void Call(EFlThreadIOCall func);
 172     /// <param name="func">No description supplied.</param>
 173 /// <returns>No description supplied.</returns>
 174 System.IntPtr CallSync(EFlThreadIOCallSync func);
 175                             /// <value>No description supplied.</value>
 176     System.IntPtr Indata {
 177         get ;
 178         set ;
 179     }
 180     /// <value>No description supplied.</value>
 181     System.IntPtr Outdata {
 182         get ;
 183         set ;
 184     }
 185 }
 186 /// <summary>No description supplied.</summary>
 187 sealed public class IThreadIOConcrete :
 188     Efl.Eo.EoWrapper
 189     , IThreadIO
 190
 191 {
 192     ///<summary>Pointer to the native class description.</summary>
 193     public override System.IntPtr NativeClass
 194     {
 195         get
 196         {
 197             if (((object)this).GetType() == typeof(IThreadIOConcrete))
 198             {
 199                 return GetEflClassStatic();
 200             }
 201             else
 202             {
 203                 return Efl.Eo.ClassRegister.klassFromType[((object)this).GetType()];
 204             }
 205         }
 206     }
 207
 208     /// <summary>Constructor to be used when objects are expected to be constructed from native code.</summary>
 209     /// <param name="ch">Tag struct storing the native handle of the object being constructed.</param>
 210     private IThreadIOConcrete(ConstructingHandle ch) : base(ch)
 211     {
 212     }
 213
 214     [System.Runtime.InteropServices.DllImport(efl.Libs.Ecore)] internal static extern System.IntPtr
 215         efl_threadio_mixin_get();
 216     /// <summary>Initializes a new instance of the <see cref="IThreadIO"/> class.
 217     /// Internal usage: This is used when interacting with C code and should not be used directly.</summary>
 218     /// <param name="wh">The native pointer to be wrapped.</param>
 219     private IThreadIOConcrete(Efl.Eo.Globals.WrappingHandle wh) : base(wh)
 220     {
 221     }
 222
 223     /// <returns>No description supplied.</returns>
 224     public System.IntPtr GetIndata() {
 225          var _ret_var = Efl.IThreadIOConcrete.NativeMethods.efl_threadio_indata_get_ptr.Value.Delegate(this.NativeHandle);
 226         Eina.Error.RaiseIfUnhandledException();
 227         return _ret_var;
 228  }
 229     /// <param name="data">No description supplied.</param>
 230     public void SetIndata(System.IntPtr data) {
 231                                  Efl.IThreadIOConcrete.NativeMethods.efl_threadio_indata_set_ptr.Value.Delegate(this.NativeHandle,data);
 232         Eina.Error.RaiseIfUnhandledException();
 233                          }
 234     /// <returns>No description supplied.</returns>
 235     public System.IntPtr GetOutdata() {
 236          var _ret_var = Efl.IThreadIOConcrete.NativeMethods.efl_threadio_outdata_get_ptr.Value.Delegate(this.NativeHandle);
 237         Eina.Error.RaiseIfUnhandledException();
 238         return _ret_var;
 239  }
 240     /// <param name="data">No description supplied.</param>
 241     public void SetOutdata(System.IntPtr data) {
 242                                  Efl.IThreadIOConcrete.NativeMethods.efl_threadio_outdata_set_ptr.Value.Delegate(this.NativeHandle,data);
 243         Eina.Error.RaiseIfUnhandledException();
 244                          }
 245     /// <param name="func">No description supplied.</param>
 246     public void Call(EFlThreadIOCall func) {
 247                          GCHandle func_handle = GCHandle.Alloc(func);
 248         Efl.IThreadIOConcrete.NativeMethods.efl_threadio_call_ptr.Value.Delegate(this.NativeHandle,GCHandle.ToIntPtr(func_handle), EFlThreadIOCallWrapper.Cb, Efl.Eo.Globals.free_gchandle);
 249         Eina.Error.RaiseIfUnhandledException();
 250                          }
 251     /// <param name="func">No description supplied.</param>
 252     /// <returns>No description supplied.</returns>
 253     public System.IntPtr CallSync(EFlThreadIOCallSync func) {
 254                          GCHandle func_handle = GCHandle.Alloc(func);
 255         var _ret_var = Efl.IThreadIOConcrete.NativeMethods.efl_threadio_call_sync_ptr.Value.Delegate(this.NativeHandle,GCHandle.ToIntPtr(func_handle), EFlThreadIOCallSyncWrapper.Cb, Efl.Eo.Globals.free_gchandle);
 256         Eina.Error.RaiseIfUnhandledException();
 257                         return _ret_var;
 258  }
 259     /// <value>No description supplied.</value>
 260     public System.IntPtr Indata {
 261         get { return GetIndata(); }
 262         set { SetIndata(value); }
 263     }
 264     /// <value>No description supplied.</value>
 265     public System.IntPtr Outdata {
 266         get { return GetOutdata(); }
 267         set { SetOutdata(value); }
 268     }
 269     private static IntPtr GetEflClassStatic()
 270     {
 271         return Efl.IThreadIOConcrete.efl_threadio_mixin_get();
 272     }
 273     /// <summary>Wrapper for native methods and virtual method delegates.
 274     /// For internal use by generated code only.</summary>
 275     public new class NativeMethods : Efl.Eo.EoWrapper.NativeMethods
 276     {
 277         private static Efl.Eo.NativeModule Module = new Efl.Eo.NativeModule(    efl.Libs.Ecore);
 278         /// <summary>Gets the list of Eo operations to override.</summary>
 279         /// <returns>The list of Eo operations to be overload.</returns>
 280         public override System.Collections.Generic.List<Efl_Op_Description> GetEoOps(System.Type type)
 281         {
 282             var descs = new System.Collections.Generic.List<Efl_Op_Description>();
 283             var methods = Efl.Eo.Globals.GetUserMethods(type);
 284
 285             if (efl_threadio_indata_get_static_delegate == null)
 286             {
 287                 efl_threadio_indata_get_static_delegate = new efl_threadio_indata_get_delegate(indata_get);
 288             }
 289
 290             if (methods.FirstOrDefault(m => m.Name == "GetIndata") != null)
 291             {
 292                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_threadio_indata_get"), func = Marshal.GetFunctionPointerForDelegate(efl_threadio_indata_get_static_delegate) });
 293             }
 294
 295             if (efl_threadio_indata_set_static_delegate == null)
 296             {
 297                 efl_threadio_indata_set_static_delegate = new efl_threadio_indata_set_delegate(indata_set);
 298             }
 299
 300             if (methods.FirstOrDefault(m => m.Name == "SetIndata") != null)
 301             {
 302                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_threadio_indata_set"), func = Marshal.GetFunctionPointerForDelegate(efl_threadio_indata_set_static_delegate) });
 303             }
 304
 305             if (efl_threadio_outdata_get_static_delegate == null)
 306             {
 307                 efl_threadio_outdata_get_static_delegate = new efl_threadio_outdata_get_delegate(outdata_get);
 308             }
 309
 310             if (methods.FirstOrDefault(m => m.Name == "GetOutdata") != null)
 311             {
 312                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_threadio_outdata_get"), func = Marshal.GetFunctionPointerForDelegate(efl_threadio_outdata_get_static_delegate) });
 313             }
 314
 315             if (efl_threadio_outdata_set_static_delegate == null)
 316             {
 317                 efl_threadio_outdata_set_static_delegate = new efl_threadio_outdata_set_delegate(outdata_set);
 318             }
 319
 320             if (methods.FirstOrDefault(m => m.Name == "SetOutdata") != null)
 321             {
 322                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_threadio_outdata_set"), func = Marshal.GetFunctionPointerForDelegate(efl_threadio_outdata_set_static_delegate) });
 323             }
 324
 325             if (efl_threadio_call_static_delegate == null)
 326             {
 327                 efl_threadio_call_static_delegate = new efl_threadio_call_delegate(call);
 328             }
 329
 330             if (methods.FirstOrDefault(m => m.Name == "Call") != null)
 331             {
 332                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_threadio_call"), func = Marshal.GetFunctionPointerForDelegate(efl_threadio_call_static_delegate) });
 333             }
 334
 335             if (efl_threadio_call_sync_static_delegate == null)
 336             {
 337                 efl_threadio_call_sync_static_delegate = new efl_threadio_call_sync_delegate(call_sync);
 338             }
 339
 340             if (methods.FirstOrDefault(m => m.Name == "CallSync") != null)
 341             {
 342                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_threadio_call_sync"), func = Marshal.GetFunctionPointerForDelegate(efl_threadio_call_sync_static_delegate) });
 343             }
 344
 345             return descs;
 346         }
 347         /// <summary>Returns the Eo class for the native methods of this class.</summary>
 348         /// <returns>The native class pointer.</returns>
 349         public override IntPtr GetEflClass()
 350         {
 351             return Efl.IThreadIOConcrete.efl_threadio_mixin_get();
 352         }
 353
 354         #pragma warning disable CA1707, CS1591, SA1300, SA1600
 355
 356
 357         private delegate System.IntPtr efl_threadio_indata_get_delegate(System.IntPtr obj, System.IntPtr pd);
 358
 359
 360         public delegate System.IntPtr efl_threadio_indata_get_api_delegate(System.IntPtr obj);
 361
 362         public static Efl.Eo.FunctionWrapper<efl_threadio_indata_get_api_delegate> efl_threadio_indata_get_ptr = new Efl.Eo.FunctionWrapper<efl_threadio_indata_get_api_delegate>(Module, "efl_threadio_indata_get");
 363
 364         private static System.IntPtr indata_get(System.IntPtr obj, System.IntPtr pd)
 365         {
 366             Eina.Log.Debug("function efl_threadio_indata_get was called");
 367             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 368             if (ws != null)
 369             {
 370             System.IntPtr _ret_var = default(System.IntPtr);
 371                 try
 372                 {
 373                     _ret_var = ((IThreadIO)ws.Target).GetIndata();
 374                 }
 375                 catch (Exception e)
 376                 {
 377                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 378                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 379                 }
 380
 381         return _ret_var;
 382
 383             }
 384             else
 385             {
 386                 return efl_threadio_indata_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
 387             }
 388         }
 389
 390         private static efl_threadio_indata_get_delegate efl_threadio_indata_get_static_delegate;
 391
 392
 393         private delegate void efl_threadio_indata_set_delegate(System.IntPtr obj, System.IntPtr pd,  System.IntPtr data);
 394
 395
 396         public delegate void efl_threadio_indata_set_api_delegate(System.IntPtr obj,  System.IntPtr data);
 397
 398         public static Efl.Eo.FunctionWrapper<efl_threadio_indata_set_api_delegate> efl_threadio_indata_set_ptr = new Efl.Eo.FunctionWrapper<efl_threadio_indata_set_api_delegate>(Module, "efl_threadio_indata_set");
 399
 400         private static void indata_set(System.IntPtr obj, System.IntPtr pd, System.IntPtr data)
 401         {
 402             Eina.Log.Debug("function efl_threadio_indata_set was called");
 403             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 404             if (ws != null)
 405             {
 406
 407                 try
 408                 {
 409                     ((IThreadIO)ws.Target).SetIndata(data);
 410                 }
 411                 catch (Exception e)
 412                 {
 413                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 414                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 415                 }
 416
 417
 418             }
 419             else
 420             {
 421                 efl_threadio_indata_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), data);
 422             }
 423         }
 424
 425         private static efl_threadio_indata_set_delegate efl_threadio_indata_set_static_delegate;
 426
 427
 428         private delegate System.IntPtr efl_threadio_outdata_get_delegate(System.IntPtr obj, System.IntPtr pd);
 429
 430
 431         public delegate System.IntPtr efl_threadio_outdata_get_api_delegate(System.IntPtr obj);
 432
 433         public static Efl.Eo.FunctionWrapper<efl_threadio_outdata_get_api_delegate> efl_threadio_outdata_get_ptr = new Efl.Eo.FunctionWrapper<efl_threadio_outdata_get_api_delegate>(Module, "efl_threadio_outdata_get");
 434
 435         private static System.IntPtr outdata_get(System.IntPtr obj, System.IntPtr pd)
 436         {
 437             Eina.Log.Debug("function efl_threadio_outdata_get was called");
 438             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 439             if (ws != null)
 440             {
 441             System.IntPtr _ret_var = default(System.IntPtr);
 442                 try
 443                 {
 444                     _ret_var = ((IThreadIO)ws.Target).GetOutdata();
 445                 }
 446                 catch (Exception e)
 447                 {
 448                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 449                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 450                 }
 451
 452         return _ret_var;
 453
 454             }
 455             else
 456             {
 457                 return efl_threadio_outdata_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
 458             }
 459         }
 460
 461         private static efl_threadio_outdata_get_delegate efl_threadio_outdata_get_static_delegate;
 462
 463
 464         private delegate void efl_threadio_outdata_set_delegate(System.IntPtr obj, System.IntPtr pd,  System.IntPtr data);
 465
 466
 467         public delegate void efl_threadio_outdata_set_api_delegate(System.IntPtr obj,  System.IntPtr data);
 468
 469         public static Efl.Eo.FunctionWrapper<efl_threadio_outdata_set_api_delegate> efl_threadio_outdata_set_ptr = new Efl.Eo.FunctionWrapper<efl_threadio_outdata_set_api_delegate>(Module, "efl_threadio_outdata_set");
 470
 471         private static void outdata_set(System.IntPtr obj, System.IntPtr pd, System.IntPtr data)
 472         {
 473             Eina.Log.Debug("function efl_threadio_outdata_set was called");
 474             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 475             if (ws != null)
 476             {
 477
 478                 try
 479                 {
 480                     ((IThreadIO)ws.Target).SetOutdata(data);
 481                 }
 482                 catch (Exception e)
 483                 {
 484                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 485                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 486                 }
 487
 488
 489             }
 490             else
 491             {
 492                 efl_threadio_outdata_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), data);
 493             }
 494         }
 495
 496         private static efl_threadio_outdata_set_delegate efl_threadio_outdata_set_static_delegate;
 497
 498
 499         private delegate void efl_threadio_call_delegate(System.IntPtr obj, System.IntPtr pd,  IntPtr func_data, EFlThreadIOCallInternal func, EinaFreeCb func_free_cb);
 500
 501
 502         public delegate void efl_threadio_call_api_delegate(System.IntPtr obj,  IntPtr func_data, EFlThreadIOCallInternal func, EinaFreeCb func_free_cb);
 503
 504         public static Efl.Eo.FunctionWrapper<efl_threadio_call_api_delegate> efl_threadio_call_ptr = new Efl.Eo.FunctionWrapper<efl_threadio_call_api_delegate>(Module, "efl_threadio_call");
 505
 506         private static void call(System.IntPtr obj, System.IntPtr pd, IntPtr func_data, EFlThreadIOCallInternal func, EinaFreeCb func_free_cb)
 507         {
 508             Eina.Log.Debug("function efl_threadio_call was called");
 509             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 510             if (ws != null)
 511             {
 512                             EFlThreadIOCallWrapper func_wrapper = new EFlThreadIOCallWrapper(func, func_data, func_free_cb);
 513
 514                 try
 515                 {
 516                     ((IThreadIO)ws.Target).Call(func_wrapper.ManagedCb);
 517                 }
 518                 catch (Exception e)
 519                 {
 520                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 521                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 522                 }
 523
 524
 525             }
 526             else
 527             {
 528                 efl_threadio_call_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), func_data, func, func_free_cb);
 529             }
 530         }
 531
 532         private static efl_threadio_call_delegate efl_threadio_call_static_delegate;
 533
 534
 535         private delegate System.IntPtr efl_threadio_call_sync_delegate(System.IntPtr obj, System.IntPtr pd,  IntPtr func_data, EFlThreadIOCallSyncInternal func, EinaFreeCb func_free_cb);
 536
 537
 538         public delegate System.IntPtr efl_threadio_call_sync_api_delegate(System.IntPtr obj,  IntPtr func_data, EFlThreadIOCallSyncInternal func, EinaFreeCb func_free_cb);
 539
 540         public static Efl.Eo.FunctionWrapper<efl_threadio_call_sync_api_delegate> efl_threadio_call_sync_ptr = new Efl.Eo.FunctionWrapper<efl_threadio_call_sync_api_delegate>(Module, "efl_threadio_call_sync");
 541
 542         private static System.IntPtr call_sync(System.IntPtr obj, System.IntPtr pd, IntPtr func_data, EFlThreadIOCallSyncInternal func, EinaFreeCb func_free_cb)
 543         {
 544             Eina.Log.Debug("function efl_threadio_call_sync was called");
 545             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 546             if (ws != null)
 547             {
 548                             EFlThreadIOCallSyncWrapper func_wrapper = new EFlThreadIOCallSyncWrapper(func, func_data, func_free_cb);
 549             System.IntPtr _ret_var = default(System.IntPtr);
 550                 try
 551                 {
 552                     _ret_var = ((IThreadIO)ws.Target).CallSync(func_wrapper.ManagedCb);
 553                 }
 554                 catch (Exception e)
 555                 {
 556                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 557                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 558                 }
 559
 560                         return _ret_var;
 561
 562             }
 563             else
 564             {
 565                 return efl_threadio_call_sync_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), func_data, func, func_free_cb);
 566             }
 567         }
 568
 569         private static efl_threadio_call_sync_delegate efl_threadio_call_sync_static_delegate;
 570
 571         #pragma warning restore CA1707, CS1591, SA1300, SA1600
 572
 573 }
 574 }
 575 }
 576