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