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