internals/src/EflSharp/EflSharp/efl/efl_ui_item_part_text.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 /// <summary>Item internal text part class</summary>
  13 [Efl.Ui.ItemPartText.NativeMethods]
  14 [Efl.Eo.BindingEntity]
  15 public class ItemPartText : Efl.Ui.LayoutPart, Efl.IText, Efl.ITextMarkup, Efl.Ui.IL10n
  16 {
  17     ///<summary>Pointer to the native class description.</summary>
  18     public override System.IntPtr NativeClass
  19     {
  20         get
  21         {
  22             if (((object)this).GetType() == typeof(ItemPartText))
  23             {
  24                 return GetEflClassStatic();
  25             }
  26             else
  27             {
  28                 return Efl.Eo.ClassRegister.klassFromType[((object)this).GetType()];
  29             }
  30         }
  31     }
  32
  33     [System.Runtime.InteropServices.DllImport(efl.Libs.Elementary)] internal static extern System.IntPtr
  34         efl_ui_item_part_text_class_get();
  35     /// <summary>Initializes a new instance of the <see cref="ItemPartText"/> class.</summary>
  36     /// <param name="parent">Parent instance.</param>
  37     public ItemPartText(Efl.Object parent= null
  38             ) : base(efl_ui_item_part_text_class_get(), parent)
  39     {
  40         FinishInstantiation();
  41     }
  42
  43     /// <summary>Constructor to be used when objects are expected to be constructed from native code.</summary>
  44     /// <param name="ch">Tag struct storing the native handle of the object being constructed.</param>
  45     protected ItemPartText(ConstructingHandle ch) : base(ch)
  46     {
  47     }
  48
  49     /// <summary>Initializes a new instance of the <see cref="ItemPartText"/> class.
  50     /// Internal usage: Constructs an instance from a native pointer. This is used when interacting with C code and should not be used directly.</summary>
  51     /// <param name="wh">The native pointer to be wrapped.</param>
  52     protected ItemPartText(Efl.Eo.Globals.WrappingHandle wh) : base(wh)
  53     {
  54     }
  55
  56     /// <summary>Initializes a new instance of the <see cref="ItemPartText"/> class.
  57     /// Internal usage: Constructor to forward the wrapper initialization to the root class that interfaces with native code. Should not be used directly.</summary>
  58     /// <param name="baseKlass">The pointer to the base native Eo class.</param>
  59     /// <param name="parent">The Efl.Object parent of this instance.</param>
  60     protected ItemPartText(IntPtr baseKlass, Efl.Object parent) : base(baseKlass, parent)
  61     {
  62     }
  63
  64     /// <summary>Retrieves the text string currently being displayed by the given text object.
  65     /// Do not free() the return value.
  66     ///
  67     /// See also <see cref="Efl.IText.GetText"/>.
  68     /// (Since EFL 1.22)</summary>
  69     /// <returns>Text string to display on it.</returns>
  70     virtual public System.String GetText() {
  71          var _ret_var = Efl.ITextConcrete.NativeMethods.efl_text_get_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)));
  72         Eina.Error.RaiseIfUnhandledException();
  73         return _ret_var;
  74  }
  75     /// <summary>Sets the text string to be displayed by the given text object.
  76     /// See also <see cref="Efl.IText.GetText"/>.
  77     /// (Since EFL 1.22)</summary>
  78     /// <param name="text">Text string to display on it.</param>
  79     virtual public void SetText(System.String text) {
  80                                  Efl.ITextConcrete.NativeMethods.efl_text_set_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)),text);
  81         Eina.Error.RaiseIfUnhandledException();
  82                          }
  83     /// <summary>Markup property</summary>
  84     /// <returns>The markup-text representation set to this text.</returns>
  85     virtual public System.String GetMarkup() {
  86          var _ret_var = Efl.ITextMarkupConcrete.NativeMethods.efl_text_markup_get_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)));
  87         Eina.Error.RaiseIfUnhandledException();
  88         return _ret_var;
  89  }
  90     /// <summary>Markup property</summary>
  91     /// <param name="markup">The markup-text representation set to this text.</param>
  92     virtual public void SetMarkup(System.String markup) {
  93                                  Efl.ITextMarkupConcrete.NativeMethods.efl_text_markup_set_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)),markup);
  94         Eina.Error.RaiseIfUnhandledException();
  95                          }
  96     /// <summary>A unique string to be translated.
  97     /// Often this will be a human-readable string (e.g. in English) but it can also be a unique string identifier that must then be translated to the current locale with <c>dgettext</c>() or any similar mechanism.
  98     ///
  99     /// Setting this property will enable translation for this object or part.</summary>
 100     /// <param name="domain">A translation domain. If <c>null</c> this means the default domain is used.</param>
 101     /// <returns>This returns the untranslated value of <c>label</c>. The translated string can usually be retrieved with <see cref="Efl.IText.GetText"/>.</returns>
 102     virtual public System.String GetL10nText(out System.String domain) {
 103                                  var _ret_var = Efl.Ui.IL10nConcrete.NativeMethods.efl_ui_l10n_text_get_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)),out domain);
 104         Eina.Error.RaiseIfUnhandledException();
 105                         return _ret_var;
 106  }
 107     /// <summary>Sets the new untranslated string and domain for this object.</summary>
 108     /// <param name="label">A unique (untranslated) string.</param>
 109     /// <param name="domain">A translation domain. If <c>null</c> this uses the default domain (eg. set by <c>textdomain</c>()).</param>
 110     virtual public void SetL10nText(System.String label, System.String domain) {
 111                                                          Efl.Ui.IL10nConcrete.NativeMethods.efl_ui_l10n_text_set_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)),label, domain);
 112         Eina.Error.RaiseIfUnhandledException();
 113                                          }
 114     /// <summary>Requests this object to update its text strings for the current locale.
 115     /// Currently strings are translated with <c>dgettext</c>, so support for this function may depend on the platform. It is up to the application to provide its own translation data.
 116     ///
 117     /// This function is a hook meant to be implemented by any object that supports translation. This can be called whenever a new object is created or when the current locale changes, for instance. This should only trigger further calls to <see cref="Efl.Ui.IL10n.UpdateTranslation"/> to children objects.</summary>
 118     virtual public void UpdateTranslation() {
 119          Efl.Ui.IL10nConcrete.NativeMethods.efl_ui_l10n_translation_update_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)));
 120         Eina.Error.RaiseIfUnhandledException();
 121          }
 122     /// <summary>Markup property</summary>
 123     /// <value>The markup-text representation set to this text.</value>
 124     public System.String Markup {
 125         get { return GetMarkup(); }
 126         set { SetMarkup(value); }
 127     }
 128     private static IntPtr GetEflClassStatic()
 129     {
 130         return Efl.Ui.ItemPartText.efl_ui_item_part_text_class_get();
 131     }
 132     /// <summary>Wrapper for native methods and virtual method delegates.
 133     /// For internal use by generated code only.</summary>
 134     public new class NativeMethods : Efl.Ui.LayoutPart.NativeMethods
 135     {
 136         private static Efl.Eo.NativeModule Module = new Efl.Eo.NativeModule(    efl.Libs.Elementary);
 137         /// <summary>Gets the list of Eo operations to override.</summary>
 138         /// <returns>The list of Eo operations to be overload.</returns>
 139         public override System.Collections.Generic.List<Efl_Op_Description> GetEoOps(System.Type type)
 140         {
 141             var descs = new System.Collections.Generic.List<Efl_Op_Description>();
 142             var methods = Efl.Eo.Globals.GetUserMethods(type);
 143
 144             if (efl_text_get_static_delegate == null)
 145             {
 146                 efl_text_get_static_delegate = new efl_text_get_delegate(text_get);
 147             }
 148
 149             if (methods.FirstOrDefault(m => m.Name == "GetText") != null)
 150             {
 151                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_text_get"), func = Marshal.GetFunctionPointerForDelegate(efl_text_get_static_delegate) });
 152             }
 153
 154             if (efl_text_set_static_delegate == null)
 155             {
 156                 efl_text_set_static_delegate = new efl_text_set_delegate(text_set);
 157             }
 158
 159             if (methods.FirstOrDefault(m => m.Name == "SetText") != null)
 160             {
 161                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_text_set"), func = Marshal.GetFunctionPointerForDelegate(efl_text_set_static_delegate) });
 162             }
 163
 164             if (efl_text_markup_get_static_delegate == null)
 165             {
 166                 efl_text_markup_get_static_delegate = new efl_text_markup_get_delegate(markup_get);
 167             }
 168
 169             if (methods.FirstOrDefault(m => m.Name == "GetMarkup") != null)
 170             {
 171                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_text_markup_get"), func = Marshal.GetFunctionPointerForDelegate(efl_text_markup_get_static_delegate) });
 172             }
 173
 174             if (efl_text_markup_set_static_delegate == null)
 175             {
 176                 efl_text_markup_set_static_delegate = new efl_text_markup_set_delegate(markup_set);
 177             }
 178
 179             if (methods.FirstOrDefault(m => m.Name == "SetMarkup") != null)
 180             {
 181                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_text_markup_set"), func = Marshal.GetFunctionPointerForDelegate(efl_text_markup_set_static_delegate) });
 182             }
 183
 184             if (efl_ui_l10n_text_get_static_delegate == null)
 185             {
 186                 efl_ui_l10n_text_get_static_delegate = new efl_ui_l10n_text_get_delegate(l10n_text_get);
 187             }
 188
 189             if (methods.FirstOrDefault(m => m.Name == "GetL10nText") != null)
 190             {
 191                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_ui_l10n_text_get"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_l10n_text_get_static_delegate) });
 192             }
 193
 194             if (efl_ui_l10n_text_set_static_delegate == null)
 195             {
 196                 efl_ui_l10n_text_set_static_delegate = new efl_ui_l10n_text_set_delegate(l10n_text_set);
 197             }
 198
 199             if (methods.FirstOrDefault(m => m.Name == "SetL10nText") != null)
 200             {
 201                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_ui_l10n_text_set"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_l10n_text_set_static_delegate) });
 202             }
 203
 204             if (efl_ui_l10n_translation_update_static_delegate == null)
 205             {
 206                 efl_ui_l10n_translation_update_static_delegate = new efl_ui_l10n_translation_update_delegate(translation_update);
 207             }
 208
 209             if (methods.FirstOrDefault(m => m.Name == "UpdateTranslation") != null)
 210             {
 211                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_ui_l10n_translation_update"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_l10n_translation_update_static_delegate) });
 212             }
 213
 214             descs.AddRange(base.GetEoOps(type));
 215             return descs;
 216         }
 217         /// <summary>Returns the Eo class for the native methods of this class.</summary>
 218         /// <returns>The native class pointer.</returns>
 219         public override IntPtr GetEflClass()
 220         {
 221             return Efl.Ui.ItemPartText.efl_ui_item_part_text_class_get();
 222         }
 223
 224         #pragma warning disable CA1707, CS1591, SA1300, SA1600
 225
 226         [return: MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))]
 227         private delegate System.String efl_text_get_delegate(System.IntPtr obj, System.IntPtr pd);
 228
 229         [return: MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))]
 230         public delegate System.String efl_text_get_api_delegate(System.IntPtr obj);
 231
 232         public static Efl.Eo.FunctionWrapper<efl_text_get_api_delegate> efl_text_get_ptr = new Efl.Eo.FunctionWrapper<efl_text_get_api_delegate>(Module, "efl_text_get");
 233
 234         private static System.String text_get(System.IntPtr obj, System.IntPtr pd)
 235         {
 236             Eina.Log.Debug("function efl_text_get was called");
 237             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 238             if (ws != null)
 239             {
 240             System.String _ret_var = default(System.String);
 241                 try
 242                 {
 243                     _ret_var = ((ItemPartText)ws.Target).GetText();
 244                 }
 245                 catch (Exception e)
 246                 {
 247                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 248                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 249                 }
 250
 251         return _ret_var;
 252
 253             }
 254             else
 255             {
 256                 return efl_text_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
 257             }
 258         }
 259
 260         private static efl_text_get_delegate efl_text_get_static_delegate;
 261
 262
 263         private delegate void efl_text_set_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))] System.String text);
 264
 265
 266         public delegate void efl_text_set_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))] System.String text);
 267
 268         public static Efl.Eo.FunctionWrapper<efl_text_set_api_delegate> efl_text_set_ptr = new Efl.Eo.FunctionWrapper<efl_text_set_api_delegate>(Module, "efl_text_set");
 269
 270         private static void text_set(System.IntPtr obj, System.IntPtr pd, System.String text)
 271         {
 272             Eina.Log.Debug("function efl_text_set was called");
 273             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 274             if (ws != null)
 275             {
 276
 277                 try
 278                 {
 279                     ((ItemPartText)ws.Target).SetText(text);
 280                 }
 281                 catch (Exception e)
 282                 {
 283                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 284                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 285                 }
 286
 287
 288             }
 289             else
 290             {
 291                 efl_text_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), text);
 292             }
 293         }
 294
 295         private static efl_text_set_delegate efl_text_set_static_delegate;
 296
 297         [return: MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))]
 298         private delegate System.String efl_text_markup_get_delegate(System.IntPtr obj, System.IntPtr pd);
 299
 300         [return: MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))]
 301         public delegate System.String efl_text_markup_get_api_delegate(System.IntPtr obj);
 302
 303         public static Efl.Eo.FunctionWrapper<efl_text_markup_get_api_delegate> efl_text_markup_get_ptr = new Efl.Eo.FunctionWrapper<efl_text_markup_get_api_delegate>(Module, "efl_text_markup_get");
 304
 305         private static System.String markup_get(System.IntPtr obj, System.IntPtr pd)
 306         {
 307             Eina.Log.Debug("function efl_text_markup_get was called");
 308             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 309             if (ws != null)
 310             {
 311             System.String _ret_var = default(System.String);
 312                 try
 313                 {
 314                     _ret_var = ((ItemPartText)ws.Target).GetMarkup();
 315                 }
 316                 catch (Exception e)
 317                 {
 318                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 319                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 320                 }
 321
 322         return _ret_var;
 323
 324             }
 325             else
 326             {
 327                 return efl_text_markup_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
 328             }
 329         }
 330
 331         private static efl_text_markup_get_delegate efl_text_markup_get_static_delegate;
 332
 333
 334         private delegate void efl_text_markup_set_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))] System.String markup);
 335
 336
 337         public delegate void efl_text_markup_set_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))] System.String markup);
 338
 339         public static Efl.Eo.FunctionWrapper<efl_text_markup_set_api_delegate> efl_text_markup_set_ptr = new Efl.Eo.FunctionWrapper<efl_text_markup_set_api_delegate>(Module, "efl_text_markup_set");
 340
 341         private static void markup_set(System.IntPtr obj, System.IntPtr pd, System.String markup)
 342         {
 343             Eina.Log.Debug("function efl_text_markup_set was called");
 344             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 345             if (ws != null)
 346             {
 347
 348                 try
 349                 {
 350                     ((ItemPartText)ws.Target).SetMarkup(markup);
 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
 359             }
 360             else
 361             {
 362                 efl_text_markup_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), markup);
 363             }
 364         }
 365
 366         private static efl_text_markup_set_delegate efl_text_markup_set_static_delegate;
 367
 368         [return: MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))]
 369         private delegate System.String efl_ui_l10n_text_get_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))] out System.String domain);
 370
 371         [return: MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))]
 372         public delegate System.String efl_ui_l10n_text_get_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))] out System.String domain);
 373
 374         public static Efl.Eo.FunctionWrapper<efl_ui_l10n_text_get_api_delegate> efl_ui_l10n_text_get_ptr = new Efl.Eo.FunctionWrapper<efl_ui_l10n_text_get_api_delegate>(Module, "efl_ui_l10n_text_get");
 375
 376         private static System.String l10n_text_get(System.IntPtr obj, System.IntPtr pd, out System.String domain)
 377         {
 378             Eina.Log.Debug("function efl_ui_l10n_text_get was called");
 379             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 380             if (ws != null)
 381             {
 382                 System.String _out_domain = default(System.String);
 383                     System.String _ret_var = default(System.String);
 384                 try
 385                 {
 386                     _ret_var = ((ItemPartText)ws.Target).GetL10nText(out _out_domain);
 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         domain = _out_domain;
 395                 return _ret_var;
 396
 397             }
 398             else
 399             {
 400                 return efl_ui_l10n_text_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), out domain);
 401             }
 402         }
 403
 404         private static efl_ui_l10n_text_get_delegate efl_ui_l10n_text_get_static_delegate;
 405
 406
 407         private delegate void efl_ui_l10n_text_set_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))] System.String label, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))] System.String domain);
 408
 409
 410         public delegate void efl_ui_l10n_text_set_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))] System.String label, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))] System.String domain);
 411
 412         public static Efl.Eo.FunctionWrapper<efl_ui_l10n_text_set_api_delegate> efl_ui_l10n_text_set_ptr = new Efl.Eo.FunctionWrapper<efl_ui_l10n_text_set_api_delegate>(Module, "efl_ui_l10n_text_set");
 413
 414         private static void l10n_text_set(System.IntPtr obj, System.IntPtr pd, System.String label, System.String domain)
 415         {
 416             Eina.Log.Debug("function efl_ui_l10n_text_set was called");
 417             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 418             if (ws != null)
 419             {
 420
 421                 try
 422                 {
 423                     ((ItemPartText)ws.Target).SetL10nText(label, domain);
 424                 }
 425                 catch (Exception e)
 426                 {
 427                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 428                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 429                 }
 430
 431
 432             }
 433             else
 434             {
 435                 efl_ui_l10n_text_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), label, domain);
 436             }
 437         }
 438
 439         private static efl_ui_l10n_text_set_delegate efl_ui_l10n_text_set_static_delegate;
 440
 441
 442         private delegate void efl_ui_l10n_translation_update_delegate(System.IntPtr obj, System.IntPtr pd);
 443
 444
 445         public delegate void efl_ui_l10n_translation_update_api_delegate(System.IntPtr obj);
 446
 447         public static Efl.Eo.FunctionWrapper<efl_ui_l10n_translation_update_api_delegate> efl_ui_l10n_translation_update_ptr = new Efl.Eo.FunctionWrapper<efl_ui_l10n_translation_update_api_delegate>(Module, "efl_ui_l10n_translation_update");
 448
 449         private static void translation_update(System.IntPtr obj, System.IntPtr pd)
 450         {
 451             Eina.Log.Debug("function efl_ui_l10n_translation_update was called");
 452             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 453             if (ws != null)
 454             {
 455
 456                 try
 457                 {
 458                     ((ItemPartText)ws.Target).UpdateTranslation();
 459                 }
 460                 catch (Exception e)
 461                 {
 462                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 463                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 464                 }
 465
 466
 467             }
 468             else
 469             {
 470                 efl_ui_l10n_translation_update_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
 471             }
 472         }
 473
 474         private static efl_ui_l10n_translation_update_delegate efl_ui_l10n_translation_update_static_delegate;
 475
 476         #pragma warning restore CA1707, CS1591, SA1300, SA1600
 477
 478 }
 479 }
 480 }
 481
 482 }
 483