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