internals/src/EflSharp/EflSharp/efl/efl_ui_focus_composition.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 namespace Efl {
   9
  10 namespace Ui {
  11
  12 namespace Focus {
  13
  14 /// <summary>This defines the inheriting widget as Composition widget.
  15 /// A composition widget is a widget that&apos;s the logical parent of another set of widgets which can be used for interaction.</summary>
  16 [Efl.Ui.Focus.ICompositionConcrete.NativeMethods]
  17 public interface IComposition :
  18     Efl.Eo.IWrapper, IDisposable
  19 {
  20     /// <summary>Set the order of elements that will be used for composition
  21 /// Elements of the list can be either an Efl.Ui.Widget, an Efl.Ui.Focus.Object or an Efl.Gfx.
  22 ///
  23 /// If the element is an Efl.Gfx.Entity, then the geometry is used as focus geometry, the focus property is redirected to the evas focus property. The mixin will take care of registration.
  24 ///
  25 /// If the element is an Efl.Ui.Focus.Object, then the mixin will take care of registering the element.
  26 ///
  27 /// If the element is a Efl.Ui.Widget nothing is done and the widget is simply part of the order.</summary>
  28 /// <returns>The order to use</returns>
  29 Eina.List<Efl.Gfx.IEntity> GetCompositionElements();
  30     /// <summary>Set the order of elements that will be used for composition
  31 /// Elements of the list can be either an Efl.Ui.Widget, an Efl.Ui.Focus.Object or an Efl.Gfx.
  32 ///
  33 /// If the element is an Efl.Gfx.Entity, then the geometry is used as focus geometry, the focus property is redirected to the evas focus property. The mixin will take care of registration.
  34 ///
  35 /// If the element is an Efl.Ui.Focus.Object, then the mixin will take care of registering the element.
  36 ///
  37 /// If the element is a Efl.Ui.Widget nothing is done and the widget is simply part of the order.</summary>
  38 /// <param name="logical_order">The order to use</param>
  39 void SetCompositionElements(Eina.List<Efl.Gfx.IEntity> logical_order);
  40     /// <summary>Set to true if all children should be registered as logicals</summary>
  41 /// <returns><c>true</c> or <c>false</c></returns>
  42 bool GetLogicalMode();
  43     /// <summary>Set to true if all children should be registered as logicals</summary>
  44 /// <param name="logical_mode"><c>true</c> or <c>false</c></param>
  45 void SetLogicalMode(bool logical_mode);
  46     /// <summary>Mark this widget as dirty, the children can be considered to be changed after that call</summary>
  47 void Dirty();
  48     /// <summary>A call to prepare the children of this element, called if marked as dirty
  49 /// You can use this function to call composition_elements.</summary>
  50 void Prepare();
  51                             /// <summary>Set the order of elements that will be used for composition
  52     /// Elements of the list can be either an Efl.Ui.Widget, an Efl.Ui.Focus.Object or an Efl.Gfx.
  53     ///
  54     /// If the element is an Efl.Gfx.Entity, then the geometry is used as focus geometry, the focus property is redirected to the evas focus property. The mixin will take care of registration.
  55     ///
  56     /// If the element is an Efl.Ui.Focus.Object, then the mixin will take care of registering the element.
  57     ///
  58     /// If the element is a Efl.Ui.Widget nothing is done and the widget is simply part of the order.</summary>
  59     /// <value>The order to use</value>
  60     Eina.List<Efl.Gfx.IEntity> CompositionElements {
  61         get ;
  62         set ;
  63     }
  64     /// <summary>Set to true if all children should be registered as logicals</summary>
  65     /// <value><c>true</c> or <c>false</c></value>
  66     bool LogicalMode {
  67         get ;
  68         set ;
  69     }
  70 }
  71 /// <summary>This defines the inheriting widget as Composition widget.
  72 /// A composition widget is a widget that&apos;s the logical parent of another set of widgets which can be used for interaction.</summary>
  73 sealed public class ICompositionConcrete :
  74     Efl.Eo.EoWrapper
  75     , IComposition
  76
  77 {
  78     ///<summary>Pointer to the native class description.</summary>
  79     public override System.IntPtr NativeClass
  80     {
  81         get
  82         {
  83             if (((object)this).GetType() == typeof(ICompositionConcrete))
  84             {
  85                 return GetEflClassStatic();
  86             }
  87             else
  88             {
  89                 return Efl.Eo.ClassRegister.klassFromType[((object)this).GetType()];
  90             }
  91         }
  92     }
  93
  94     [System.Runtime.InteropServices.DllImport(efl.Libs.Elementary)] internal static extern System.IntPtr
  95         efl_ui_focus_composition_mixin_get();
  96     /// <summary>Initializes a new instance of the <see cref="IComposition"/> class.
  97     /// Internal usage: This is used when interacting with C code and should not be used directly.</summary>
  98     private ICompositionConcrete(System.IntPtr raw) : base(raw)
  99     {
 100     }
 101
 102     /// <summary>Set the order of elements that will be used for composition
 103     /// Elements of the list can be either an Efl.Ui.Widget, an Efl.Ui.Focus.Object or an Efl.Gfx.
 104     ///
 105     /// If the element is an Efl.Gfx.Entity, then the geometry is used as focus geometry, the focus property is redirected to the evas focus property. The mixin will take care of registration.
 106     ///
 107     /// If the element is an Efl.Ui.Focus.Object, then the mixin will take care of registering the element.
 108     ///
 109     /// If the element is a Efl.Ui.Widget nothing is done and the widget is simply part of the order.</summary>
 110     /// <returns>The order to use</returns>
 111     public Eina.List<Efl.Gfx.IEntity> GetCompositionElements() {
 112          var _ret_var = Efl.Ui.Focus.ICompositionConcrete.NativeMethods.efl_ui_focus_composition_elements_get_ptr.Value.Delegate(this.NativeHandle);
 113         Eina.Error.RaiseIfUnhandledException();
 114         return new Eina.List<Efl.Gfx.IEntity>(_ret_var, true, false);
 115  }
 116     /// <summary>Set the order of elements that will be used for composition
 117     /// Elements of the list can be either an Efl.Ui.Widget, an Efl.Ui.Focus.Object or an Efl.Gfx.
 118     ///
 119     /// If the element is an Efl.Gfx.Entity, then the geometry is used as focus geometry, the focus property is redirected to the evas focus property. The mixin will take care of registration.
 120     ///
 121     /// If the element is an Efl.Ui.Focus.Object, then the mixin will take care of registering the element.
 122     ///
 123     /// If the element is a Efl.Ui.Widget nothing is done and the widget is simply part of the order.</summary>
 124     /// <param name="logical_order">The order to use</param>
 125     public void SetCompositionElements(Eina.List<Efl.Gfx.IEntity> logical_order) {
 126          var _in_logical_order = logical_order.Handle;
 127 logical_order.Own = false;
 128                         Efl.Ui.Focus.ICompositionConcrete.NativeMethods.efl_ui_focus_composition_elements_set_ptr.Value.Delegate(this.NativeHandle,_in_logical_order);
 129         Eina.Error.RaiseIfUnhandledException();
 130                          }
 131     /// <summary>Set to true if all children should be registered as logicals</summary>
 132     /// <returns><c>true</c> or <c>false</c></returns>
 133     public bool GetLogicalMode() {
 134          var _ret_var = Efl.Ui.Focus.ICompositionConcrete.NativeMethods.efl_ui_focus_composition_logical_mode_get_ptr.Value.Delegate(this.NativeHandle);
 135         Eina.Error.RaiseIfUnhandledException();
 136         return _ret_var;
 137  }
 138     /// <summary>Set to true if all children should be registered as logicals</summary>
 139     /// <param name="logical_mode"><c>true</c> or <c>false</c></param>
 140     public void SetLogicalMode(bool logical_mode) {
 141                                  Efl.Ui.Focus.ICompositionConcrete.NativeMethods.efl_ui_focus_composition_logical_mode_set_ptr.Value.Delegate(this.NativeHandle,logical_mode);
 142         Eina.Error.RaiseIfUnhandledException();
 143                          }
 144     /// <summary>Mark this widget as dirty, the children can be considered to be changed after that call</summary>
 145     public void Dirty() {
 146          Efl.Ui.Focus.ICompositionConcrete.NativeMethods.efl_ui_focus_composition_dirty_ptr.Value.Delegate(this.NativeHandle);
 147         Eina.Error.RaiseIfUnhandledException();
 148          }
 149     /// <summary>A call to prepare the children of this element, called if marked as dirty
 150     /// You can use this function to call composition_elements.</summary>
 151     public void Prepare() {
 152          Efl.Ui.Focus.ICompositionConcrete.NativeMethods.efl_ui_focus_composition_prepare_ptr.Value.Delegate(this.NativeHandle);
 153         Eina.Error.RaiseIfUnhandledException();
 154          }
 155     /// <summary>Set the order of elements that will be used for composition
 156     /// Elements of the list can be either an Efl.Ui.Widget, an Efl.Ui.Focus.Object or an Efl.Gfx.
 157     ///
 158     /// If the element is an Efl.Gfx.Entity, then the geometry is used as focus geometry, the focus property is redirected to the evas focus property. The mixin will take care of registration.
 159     ///
 160     /// If the element is an Efl.Ui.Focus.Object, then the mixin will take care of registering the element.
 161     ///
 162     /// If the element is a Efl.Ui.Widget nothing is done and the widget is simply part of the order.</summary>
 163     /// <value>The order to use</value>
 164     public Eina.List<Efl.Gfx.IEntity> CompositionElements {
 165         get { return GetCompositionElements(); }
 166         set { SetCompositionElements(value); }
 167     }
 168     /// <summary>Set to true if all children should be registered as logicals</summary>
 169     /// <value><c>true</c> or <c>false</c></value>
 170     public bool LogicalMode {
 171         get { return GetLogicalMode(); }
 172         set { SetLogicalMode(value); }
 173     }
 174     private static IntPtr GetEflClassStatic()
 175     {
 176         return Efl.Ui.Focus.ICompositionConcrete.efl_ui_focus_composition_mixin_get();
 177     }
 178     /// <summary>Wrapper for native methods and virtual method delegates.
 179     /// For internal use by generated code only.</summary>
 180     public class NativeMethods  : Efl.Eo.NativeClass
 181     {
 182         private static Efl.Eo.NativeModule Module = new Efl.Eo.NativeModule(    efl.Libs.Elementary);
 183         /// <summary>Gets the list of Eo operations to override.</summary>
 184         /// <returns>The list of Eo operations to be overload.</returns>
 185         public override System.Collections.Generic.List<Efl_Op_Description> GetEoOps(System.Type type)
 186         {
 187             var descs = new System.Collections.Generic.List<Efl_Op_Description>();
 188             var methods = Efl.Eo.Globals.GetUserMethods(type);
 189
 190             if (efl_ui_focus_composition_elements_get_static_delegate == null)
 191             {
 192                 efl_ui_focus_composition_elements_get_static_delegate = new efl_ui_focus_composition_elements_get_delegate(composition_elements_get);
 193             }
 194
 195             if (methods.FirstOrDefault(m => m.Name == "GetCompositionElements") != null)
 196             {
 197                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_ui_focus_composition_elements_get"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_focus_composition_elements_get_static_delegate) });
 198             }
 199
 200             if (efl_ui_focus_composition_elements_set_static_delegate == null)
 201             {
 202                 efl_ui_focus_composition_elements_set_static_delegate = new efl_ui_focus_composition_elements_set_delegate(composition_elements_set);
 203             }
 204
 205             if (methods.FirstOrDefault(m => m.Name == "SetCompositionElements") != null)
 206             {
 207                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_ui_focus_composition_elements_set"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_focus_composition_elements_set_static_delegate) });
 208             }
 209
 210             if (efl_ui_focus_composition_logical_mode_get_static_delegate == null)
 211             {
 212                 efl_ui_focus_composition_logical_mode_get_static_delegate = new efl_ui_focus_composition_logical_mode_get_delegate(logical_mode_get);
 213             }
 214
 215             if (methods.FirstOrDefault(m => m.Name == "GetLogicalMode") != null)
 216             {
 217                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_ui_focus_composition_logical_mode_get"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_focus_composition_logical_mode_get_static_delegate) });
 218             }
 219
 220             if (efl_ui_focus_composition_logical_mode_set_static_delegate == null)
 221             {
 222                 efl_ui_focus_composition_logical_mode_set_static_delegate = new efl_ui_focus_composition_logical_mode_set_delegate(logical_mode_set);
 223             }
 224
 225             if (methods.FirstOrDefault(m => m.Name == "SetLogicalMode") != null)
 226             {
 227                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_ui_focus_composition_logical_mode_set"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_focus_composition_logical_mode_set_static_delegate) });
 228             }
 229
 230             if (efl_ui_focus_composition_dirty_static_delegate == null)
 231             {
 232                 efl_ui_focus_composition_dirty_static_delegate = new efl_ui_focus_composition_dirty_delegate(dirty);
 233             }
 234
 235             if (methods.FirstOrDefault(m => m.Name == "Dirty") != null)
 236             {
 237                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_ui_focus_composition_dirty"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_focus_composition_dirty_static_delegate) });
 238             }
 239
 240             if (efl_ui_focus_composition_prepare_static_delegate == null)
 241             {
 242                 efl_ui_focus_composition_prepare_static_delegate = new efl_ui_focus_composition_prepare_delegate(prepare);
 243             }
 244
 245             if (methods.FirstOrDefault(m => m.Name == "Prepare") != null)
 246             {
 247                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_ui_focus_composition_prepare"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_focus_composition_prepare_static_delegate) });
 248             }
 249
 250             return descs;
 251         }
 252         /// <summary>Returns the Eo class for the native methods of this class.</summary>
 253         /// <returns>The native class pointer.</returns>
 254         public override IntPtr GetEflClass()
 255         {
 256             return Efl.Ui.Focus.ICompositionConcrete.efl_ui_focus_composition_mixin_get();
 257         }
 258
 259         #pragma warning disable CA1707, CS1591, SA1300, SA1600
 260
 261
 262         private delegate System.IntPtr efl_ui_focus_composition_elements_get_delegate(System.IntPtr obj, System.IntPtr pd);
 263
 264
 265         public delegate System.IntPtr efl_ui_focus_composition_elements_get_api_delegate(System.IntPtr obj);
 266
 267         public static Efl.Eo.FunctionWrapper<efl_ui_focus_composition_elements_get_api_delegate> efl_ui_focus_composition_elements_get_ptr = new Efl.Eo.FunctionWrapper<efl_ui_focus_composition_elements_get_api_delegate>(Module, "efl_ui_focus_composition_elements_get");
 268
 269         private static System.IntPtr composition_elements_get(System.IntPtr obj, System.IntPtr pd)
 270         {
 271             Eina.Log.Debug("function efl_ui_focus_composition_elements_get was called");
 272             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 273             if (ws != null)
 274             {
 275             Eina.List<Efl.Gfx.IEntity> _ret_var = default(Eina.List<Efl.Gfx.IEntity>);
 276                 try
 277                 {
 278                     _ret_var = ((ICompositionConcrete)ws.Target).GetCompositionElements();
 279                 }
 280                 catch (Exception e)
 281                 {
 282                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 283                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 284                 }
 285
 286         _ret_var.Own = false; return _ret_var.Handle;
 287
 288             }
 289             else
 290             {
 291                 return efl_ui_focus_composition_elements_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
 292             }
 293         }
 294
 295         private static efl_ui_focus_composition_elements_get_delegate efl_ui_focus_composition_elements_get_static_delegate;
 296
 297
 298         private delegate void efl_ui_focus_composition_elements_set_delegate(System.IntPtr obj, System.IntPtr pd,  System.IntPtr logical_order);
 299
 300
 301         public delegate void efl_ui_focus_composition_elements_set_api_delegate(System.IntPtr obj,  System.IntPtr logical_order);
 302
 303         public static Efl.Eo.FunctionWrapper<efl_ui_focus_composition_elements_set_api_delegate> efl_ui_focus_composition_elements_set_ptr = new Efl.Eo.FunctionWrapper<efl_ui_focus_composition_elements_set_api_delegate>(Module, "efl_ui_focus_composition_elements_set");
 304
 305         private static void composition_elements_set(System.IntPtr obj, System.IntPtr pd, System.IntPtr logical_order)
 306         {
 307             Eina.Log.Debug("function efl_ui_focus_composition_elements_set was called");
 308             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 309             if (ws != null)
 310             {
 311         var _in_logical_order = new Eina.List<Efl.Gfx.IEntity>(logical_order, true, false);
 312
 313                 try
 314                 {
 315                     ((ICompositionConcrete)ws.Target).SetCompositionElements(_in_logical_order);
 316                 }
 317                 catch (Exception e)
 318                 {
 319                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 320                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 321                 }
 322
 323
 324             }
 325             else
 326             {
 327                 efl_ui_focus_composition_elements_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), logical_order);
 328             }
 329         }
 330
 331         private static efl_ui_focus_composition_elements_set_delegate efl_ui_focus_composition_elements_set_static_delegate;
 332
 333         [return: MarshalAs(UnmanagedType.U1)]
 334         private delegate bool efl_ui_focus_composition_logical_mode_get_delegate(System.IntPtr obj, System.IntPtr pd);
 335
 336         [return: MarshalAs(UnmanagedType.U1)]
 337         public delegate bool efl_ui_focus_composition_logical_mode_get_api_delegate(System.IntPtr obj);
 338
 339         public static Efl.Eo.FunctionWrapper<efl_ui_focus_composition_logical_mode_get_api_delegate> efl_ui_focus_composition_logical_mode_get_ptr = new Efl.Eo.FunctionWrapper<efl_ui_focus_composition_logical_mode_get_api_delegate>(Module, "efl_ui_focus_composition_logical_mode_get");
 340
 341         private static bool logical_mode_get(System.IntPtr obj, System.IntPtr pd)
 342         {
 343             Eina.Log.Debug("function efl_ui_focus_composition_logical_mode_get was called");
 344             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 345             if (ws != null)
 346             {
 347             bool _ret_var = default(bool);
 348                 try
 349                 {
 350                     _ret_var = ((ICompositionConcrete)ws.Target).GetLogicalMode();
 351                 }
 352                 catch (Exception e)
 353                 {
 354                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 355                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 356                 }
 357
 358         return _ret_var;
 359
 360             }
 361             else
 362             {
 363                 return efl_ui_focus_composition_logical_mode_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
 364             }
 365         }
 366
 367         private static efl_ui_focus_composition_logical_mode_get_delegate efl_ui_focus_composition_logical_mode_get_static_delegate;
 368
 369
 370         private delegate void efl_ui_focus_composition_logical_mode_set_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.U1)] bool logical_mode);
 371
 372
 373         public delegate void efl_ui_focus_composition_logical_mode_set_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.U1)] bool logical_mode);
 374
 375         public static Efl.Eo.FunctionWrapper<efl_ui_focus_composition_logical_mode_set_api_delegate> efl_ui_focus_composition_logical_mode_set_ptr = new Efl.Eo.FunctionWrapper<efl_ui_focus_composition_logical_mode_set_api_delegate>(Module, "efl_ui_focus_composition_logical_mode_set");
 376
 377         private static void logical_mode_set(System.IntPtr obj, System.IntPtr pd, bool logical_mode)
 378         {
 379             Eina.Log.Debug("function efl_ui_focus_composition_logical_mode_set was called");
 380             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 381             if (ws != null)
 382             {
 383
 384                 try
 385                 {
 386                     ((ICompositionConcrete)ws.Target).SetLogicalMode(logical_mode);
 387                 }
 388                 catch (Exception e)
 389                 {
 390                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 391                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 392                 }
 393
 394
 395             }
 396             else
 397             {
 398                 efl_ui_focus_composition_logical_mode_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), logical_mode);
 399             }
 400         }
 401
 402         private static efl_ui_focus_composition_logical_mode_set_delegate efl_ui_focus_composition_logical_mode_set_static_delegate;
 403
 404
 405         private delegate void efl_ui_focus_composition_dirty_delegate(System.IntPtr obj, System.IntPtr pd);
 406
 407
 408         public delegate void efl_ui_focus_composition_dirty_api_delegate(System.IntPtr obj);
 409
 410         public static Efl.Eo.FunctionWrapper<efl_ui_focus_composition_dirty_api_delegate> efl_ui_focus_composition_dirty_ptr = new Efl.Eo.FunctionWrapper<efl_ui_focus_composition_dirty_api_delegate>(Module, "efl_ui_focus_composition_dirty");
 411
 412         private static void dirty(System.IntPtr obj, System.IntPtr pd)
 413         {
 414             Eina.Log.Debug("function efl_ui_focus_composition_dirty was called");
 415             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 416             if (ws != null)
 417             {
 418
 419                 try
 420                 {
 421                     ((ICompositionConcrete)ws.Target).Dirty();
 422                 }
 423                 catch (Exception e)
 424                 {
 425                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 426                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 427                 }
 428
 429
 430             }
 431             else
 432             {
 433                 efl_ui_focus_composition_dirty_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
 434             }
 435         }
 436
 437         private static efl_ui_focus_composition_dirty_delegate efl_ui_focus_composition_dirty_static_delegate;
 438
 439
 440         private delegate void efl_ui_focus_composition_prepare_delegate(System.IntPtr obj, System.IntPtr pd);
 441
 442
 443         public delegate void efl_ui_focus_composition_prepare_api_delegate(System.IntPtr obj);
 444
 445         public static Efl.Eo.FunctionWrapper<efl_ui_focus_composition_prepare_api_delegate> efl_ui_focus_composition_prepare_ptr = new Efl.Eo.FunctionWrapper<efl_ui_focus_composition_prepare_api_delegate>(Module, "efl_ui_focus_composition_prepare");
 446
 447         private static void prepare(System.IntPtr obj, System.IntPtr pd)
 448         {
 449             Eina.Log.Debug("function efl_ui_focus_composition_prepare was called");
 450             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 451             if (ws != null)
 452             {
 453
 454                 try
 455                 {
 456                     ((ICompositionConcrete)ws.Target).Prepare();
 457                 }
 458                 catch (Exception e)
 459                 {
 460                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 461                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 462                 }
 463
 464
 465             }
 466             else
 467             {
 468                 efl_ui_focus_composition_prepare_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
 469             }
 470         }
 471
 472         private static efl_ui_focus_composition_prepare_delegate efl_ui_focus_composition_prepare_static_delegate;
 473
 474         #pragma warning restore CA1707, CS1591, SA1300, SA1600
 475
 476 }
 477 }
 478 }
 479
 480 }
 481
 482 }
 483