src/Tizen.NUI/src/public/BaseComponents/TextLabel.cs

   1 /*
   2  * Copyright(c) 2021 Samsung Electronics Co., Ltd.
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  * http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  *
  16  */
  17
  18 extern alias TizenSystemSettings;
  19 using TizenSystemSettings.Tizen.System;
  20
  21 using System;
  22 using System.Globalization;
  23 using System.ComponentModel;
  24 using Tizen.NUI.Text;
  25
  26 namespace Tizen.NUI.BaseComponents
  27 {
  28     /// <summary>
  29     /// A control which renders a short text string.<br />
  30     /// Text labels are lightweight, non-editable, and do not respond to the user input.<br />
  31     /// </summary>
  32     /// <since_tizen> 3 </since_tizen>
  33     public partial class TextLabel : View
  34     {
  35         private class TextLayout : LayoutItem
  36         {
  37             protected override void OnMeasure(MeasureSpecification widthMeasureSpec, MeasureSpecification heightMeasureSpec)
  38             {
  39                 // Padding will be automatically applied by DALi TextLabel.
  40                 float totalWidth = widthMeasureSpec.Size.AsDecimal();
  41                 float totalHeight = heightMeasureSpec.Size.AsDecimal();
  42
  43                 if (widthMeasureSpec.Mode == MeasureSpecification.ModeType.Exactly)
  44                 {
  45                     if (heightMeasureSpec.Mode != MeasureSpecification.ModeType.Exactly)
  46                     {
  47                         totalHeight = Owner.GetHeightForWidth(totalWidth);
  48                         heightMeasureSpec = new MeasureSpecification(new LayoutLength(totalHeight), MeasureSpecification.ModeType.Exactly);
  49                     }
  50                 }
  51                 else
  52                 {
  53                     var minSize = Owner.MinimumSize;
  54                     var maxSize = Owner.MaximumSize;
  55                     var naturalSize = Owner.GetNaturalSize();
  56
  57                     if (heightMeasureSpec.Mode == MeasureSpecification.ModeType.Exactly)
  58                     {
  59                         // GetWidthForHeight is not implemented.
  60                         totalWidth = Math.Min(Math.Max(naturalSize.Width, minSize.Width), (maxSize.Width < 0 ? Int32.MaxValue : maxSize.Width));
  61                         widthMeasureSpec = new MeasureSpecification(new LayoutLength(totalWidth), MeasureSpecification.ModeType.Exactly);
  62                     }
  63                     else
  64                     {
  65                         totalWidth = Math.Min(Math.Max(naturalSize.Width, minSize.Width), (maxSize.Width < 0 ? Int32.MaxValue : maxSize.Width));
  66                         totalHeight = Math.Min(Math.Max(naturalSize.Height, minSize.Height), (maxSize.Height < 0 ? Int32.MaxValue : maxSize.Height));
  67
  68                         heightMeasureSpec = new MeasureSpecification(new LayoutLength(totalHeight), MeasureSpecification.ModeType.Exactly);
  69                         widthMeasureSpec = new MeasureSpecification(new LayoutLength(totalWidth), MeasureSpecification.ModeType.Exactly);
  70                     }
  71                 }
  72
  73                 MeasuredSize.StateType childWidthState = MeasuredSize.StateType.MeasuredSizeOK;
  74                 MeasuredSize.StateType childHeightState = MeasuredSize.StateType.MeasuredSizeOK;
  75
  76                 SetMeasuredDimensions(ResolveSizeAndState(new LayoutLength(totalWidth), widthMeasureSpec, childWidthState),
  77                                        ResolveSizeAndState(new LayoutLength(totalHeight), heightMeasureSpec, childHeightState));
  78             }
  79         }
  80
  81         static TextLabel() { }
  82
  83         private string textLabelSid = null;
  84         private bool systemlangTextFlag = false;
  85         private TextLabelSelectorData selectorData;
  86         private float fontSizeScale = 1.0f;
  87         private bool hasFontSizeChangedCallback = false;
  88
  89         /// <summary>
  90         /// Creates the TextLabel control.
  91         /// </summary>
  92         /// <since_tizen> 3 </since_tizen>
  93         public TextLabel() : this(Interop.TextLabel.New(), true)
  94         {
  95             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
  96         }
  97
  98         /// This will be public opened in next release of tizen after ACR done. Before ACR, it is used as HiddenAPI (InhouseAPI).
  99         [EditorBrowsable(EditorBrowsableState.Never)]
 100         public TextLabel(TextLabelStyle viewStyle) : this(Interop.TextLabel.New(), true, viewStyle)
 101         {
 102         }
 103
 104         /// <summary>
 105         /// Creates the TextLabel with setting the status of shown or hidden.
 106         /// </summary>
 107         /// <param name="shown">false : Not displayed (hidden), true : displayed (shown)</param>
 108         /// This will be public opened in next release of tizen after ACR done. Before ACR, it is used as HiddenAPI (InhouseAPI).
 109         [EditorBrowsable(EditorBrowsableState.Never)]
 110         public TextLabel(bool shown) : this(Interop.TextLabel.New(), true)
 111         {
 112             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 113             SetVisible(shown);
 114         }
 115
 116         /// <summary>
 117         /// Creates the TextLabel control.
 118         /// </summary>
 119         /// <param name="text">The text to display</param>
 120         /// <since_tizen> 3 </since_tizen>
 121         public TextLabel(string text) : this(Interop.TextLabel.New(text), true)
 122         {
 123             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 124         }
 125
 126         /// <summary>
 127         /// Creates the TextLabel with setting the status of shown or hidden.
 128         /// </summary>
 129         /// <param name="text">The text to display</param>
 130         /// <param name="shown">false : Not displayed (hidden), true : displayed (shown)</param>
 131         /// This will be public opened in next release of tizen after ACR done. Before ACR, it is used as HiddenAPI (InhouseAPI).
 132         [EditorBrowsable(EditorBrowsableState.Never)]
 133         public TextLabel(string text, bool shown) : this(Interop.TextLabel.New(text), true)
 134         {
 135             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 136             SetVisible(shown);
 137         }
 138
 139         internal TextLabel(TextLabel handle, bool shown = true) : this(Interop.TextLabel.NewTextLabel(TextLabel.getCPtr(handle)), true)
 140         {
 141             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 142
 143             if (!shown)
 144             {
 145                 SetVisible(false);
 146             }
 147         }
 148
 149         internal TextLabel(global::System.IntPtr cPtr, bool cMemoryOwn, ViewStyle viewStyle, bool shown = true) : base(cPtr, cMemoryOwn, viewStyle)
 150         {
 151             if (!shown)
 152             {
 153                 SetVisible(false);
 154             }
 155         }
 156
 157         internal TextLabel(global::System.IntPtr cPtr, bool cMemoryOwn, bool shown = true) : base(cPtr, cMemoryOwn, null)
 158         {
 159             if (!shown)
 160             {
 161                 SetVisible(false);
 162             }
 163         }
 164
 165         /// <summary>
 166         /// The TranslatableText property.<br />
 167         /// The text can set the SID value.<br />
 168         /// </summary>
 169         /// <exception cref='ArgumentNullException'>
 170         /// ResourceManager about multilingual is null.
 171         /// </exception>
 172         /// <since_tizen> 4 </since_tizen>
 173         public string TranslatableText
 174         {
 175             get
 176             {
 177                 return (string)GetValue(TranslatableTextProperty);
 178             }
 179             set
 180             {
 181                 SetValue(TranslatableTextProperty, value);
 182             }
 183         }
 184         private string translatableText
 185         {
 186             get
 187             {
 188                 return textLabelSid;
 189             }
 190             set
 191             {
 192                 if (NUIApplication.MultilingualResourceManager == null)
 193                 {
 194                     throw new ArgumentNullException(null, "ResourceManager about multilingual is null");
 195                 }
 196                 string translatableText = null;
 197                 textLabelSid = value;
 198                 translatableText = NUIApplication.MultilingualResourceManager?.GetString(textLabelSid, new CultureInfo(SystemSettings.LocaleLanguage.Replace("_", "-")));
 199                 if (translatableText != null)
 200                 {
 201                     Text = translatableText;
 202                     if (systemlangTextFlag == false)
 203                     {
 204                         SystemSettings.LocaleLanguageChanged += SystemSettings_LocaleLanguageChanged;
 205                         systemlangTextFlag = true;
 206                     }
 207                 }
 208                 else
 209                 {
 210                     Text = "";
 211                 }
 212                 NotifyPropertyChanged();
 213             }
 214         }
 215
 216         /// <summary>
 217         /// The Text property.<br />
 218         /// The text to display in the UTF-8 format.<br />
 219         /// </summary>
 220         /// <since_tizen> 3 </since_tizen>
 221         public string Text
 222         {
 223             get
 224             {
 225                 return (string)GetValue(TextProperty);
 226             }
 227             set
 228             {
 229                 SetValue(TextProperty, value);
 230                 NotifyPropertyChanged();
 231             }
 232         }
 233
 234         /// <summary>
 235         /// The FontFamily property.<br />
 236         /// The requested font family to use.<br />
 237         /// </summary>
 238         /// <since_tizen> 3 </since_tizen>
 239         public string FontFamily
 240         {
 241             get
 242             {
 243                 return (string)GetValue(FontFamilyProperty);
 244             }
 245             set
 246             {
 247                 SetValue(FontFamilyProperty, value);
 248                 NotifyPropertyChanged();
 249             }
 250         }
 251
 252         /// <summary>
 253         /// The FontStyle property.<br />
 254         /// The requested font style to use.<br />
 255         /// The fontStyle map contains the following keys :<br />
 256         /// <list type="table">
 257         /// <item><term>width (string)</term><description>The width key defines occupied by each glyph. (values: ultraCondensed, extraCondensed, condensed, semiCondensed, normal, semiExpanded, expanded, extraExpanded, ultraExpanded)</description></item>
 258         /// <item><term>weight (string)</term><description>The weight key defines the thickness or darkness of the glyphs. (values: thin, ultraLight, extraLight, light, demiLight, semiLight, book, normal, regular, medium, demiBold, semiBold, bold, ultraBold, extraBold, black, heavy, extraBlack)</description></item>
 259         /// <item><term>slant (string)</term><description>The slant key defines whether to use italics. (values: normal, roman, italic, oblique)</description></item>
 260         /// </list>
 261         /// </summary>
 262         /// <since_tizen> 3 </since_tizen>
 263         [System.Diagnostics.CodeAnalysis.SuppressMessage("Naming", "CA1721: Property names should not match get methods")]
 264         public PropertyMap FontStyle
 265         {
 266             get
 267             {
 268                 return (PropertyMap)GetValue(FontStyleProperty);
 269             }
 270             set
 271             {
 272                 SetValue(FontStyleProperty, value);
 273                 NotifyPropertyChanged();
 274             }
 275         }
 276
 277         /// <summary>
 278         /// Set FontStyle to TextLabel. <br />
 279         /// </summary>
 280         /// <param name="fontStyle">The FontStyle</param>
 281         /// <remarks>
 282         /// SetFontStyle specifies the requested font style through <see cref="Tizen.NUI.Text.FontStyle"/>. <br />
 283         /// </remarks>
 284         /// <example>
 285         /// The following example demonstrates how to use the SetFontStyle method.
 286         /// <code>
 287         /// var fontStyle = new Tizen.NUI.Text.FontStyle();
 288         /// fontStyle.Width = FontWidthType.Expanded;
 289         /// fontStyle.Weight = FontWeightType.Bold;
 290         /// fontStyle.Slant = FontSlantType.Italic;
 291         /// label.SetFontStyle(fontStyle);
 292         /// </code>
 293         /// </example>
 294         [EditorBrowsable(EditorBrowsableState.Never)]
 295         public void SetFontStyle(FontStyle fontStyle)
 296         {
 297             using (var fontStyleMap = TextMapHelper.GetFontStyleMap(fontStyle))
 298             {
 299                 SetValue(FontStyleProperty, fontStyleMap);
 300             }
 301         }
 302
 303         /// <summary>
 304         /// Get FontStyle from TextLabel. <br />
 305         /// </summary>
 306         /// <returns>The FontStyle</returns>
 307         /// <remarks>
 308         /// <see cref="Tizen.NUI.Text.FontStyle"/>
 309         /// </remarks>
 310         [EditorBrowsable(EditorBrowsableState.Never)]
 311         public FontStyle GetFontStyle()
 312         {
 313             FontStyle fontStyle;
 314             using (var fontStyleMap = (PropertyMap)GetValue(FontStyleProperty))
 315             {
 316                 fontStyle = TextMapHelper.GetFontStyleStruct(fontStyleMap);
 317             }
 318             return fontStyle;
 319         }
 320
 321         /// <summary>
 322         /// The PointSize property.<br />
 323         /// The size of font in points.<br />
 324         /// </summary>
 325         /// <since_tizen> 3 </since_tizen>
 326         public float PointSize
 327         {
 328             get
 329             {
 330                 return (float)GetValue(PointSizeProperty);
 331             }
 332             set
 333             {
 334                 SetValue(PointSizeProperty, value);
 335                 NotifyPropertyChanged();
 336             }
 337         }
 338
 339         /// <summary>
 340         /// The MultiLine property.<br />
 341         /// The single-line or multi-line layout option.<br />
 342         /// </summary>
 343         /// <since_tizen> 3 </since_tizen>
 344         public bool MultiLine
 345         {
 346             get
 347             {
 348                 return (bool)GetValue(MultiLineProperty);
 349             }
 350             set
 351             {
 352                 SetValue(MultiLineProperty, value);
 353                 NotifyPropertyChanged();
 354             }
 355         }
 356
 357         /// <summary>
 358         /// The HorizontalAlignment property.<br />
 359         /// The line horizontal alignment.<br />
 360         /// </summary>
 361         /// <since_tizen> 3 </since_tizen>
 362         public HorizontalAlignment HorizontalAlignment
 363         {
 364             get
 365             {
 366                 return (HorizontalAlignment)GetValue(HorizontalAlignmentProperty);
 367             }
 368             set
 369             {
 370                 SetValue(HorizontalAlignmentProperty, value);
 371                 NotifyPropertyChanged();
 372             }
 373         }
 374
 375         /// <summary>
 376         /// The VerticalAlignment property.<br />
 377         /// The line vertical alignment.<br />
 378         /// </summary>
 379         /// <since_tizen> 3 </since_tizen>
 380         public VerticalAlignment VerticalAlignment
 381         {
 382             get
 383             {
 384                 return (VerticalAlignment)GetValue(VerticalAlignmentProperty);
 385             }
 386             set
 387             {
 388                 SetValue(VerticalAlignmentProperty, value);
 389                 NotifyPropertyChanged();
 390             }
 391         }
 392
 393         /// <summary>
 394         /// The TextColor property.<br />
 395         /// The color of the text.<br />
 396         /// Animation framework can be used to change the color of the text when not using mark up.<br />
 397         /// Cannot animate the color when text is auto scrolling.<br />
 398         /// </summary>
 399         /// <remarks>
 400         /// The property cascade chaining set is possible. For example, this (textLabel.TextColor.X = 0.1f;) is possible.
 401         /// </remarks>
 402         /// <since_tizen> 3 </since_tizen>
 403         public Color TextColor
 404         {
 405             get
 406             {
 407                 Color temp = (Color)GetValue(TextColorProperty);
 408                 return new Color(OnTextColorChanged, temp.R, temp.G, temp.B, temp.A);
 409             }
 410             set
 411             {
 412                 SetValue(TextColorProperty, value);
 413                 NotifyPropertyChanged();
 414             }
 415         }
 416
 417         /// <summary>
 418         /// The ShadowOffset property.<br />
 419         /// The drop shadow offset 0 indicates no shadow.<br />
 420         /// </summary>
 421         /// <since_tizen> 3 </since_tizen>
 422         /// <remarks>
 423         /// Deprecated.(API Level 6) Use Shadow instead.
 424         /// The property cascade chaining set is possible. For example, this (textLabel.ShadowOffset.X = 0.1f;) is possible.
 425         /// </remarks>
 426         [Obsolete("Please do not use this ShadowOffset(Deprecated). Please use Shadow instead.")]
 427         public Vector2 ShadowOffset
 428         {
 429             get
 430             {
 431                 return GetValue(ShadowOffsetProperty) as Vector2;
 432             }
 433             set
 434             {
 435                 SetValue(ShadowOffsetProperty, value);
 436             }
 437         }
 438
 439         private Vector2 InternalShadowOffset
 440         {
 441             get
 442             {
 443                 float x = 0.0f, y = 0.0f;
 444                 using (var propertyValue = Shadow.Find(TextLabel.Property.SHADOW, "offset"))
 445                 using (var shadowOffset = new Vector2())
 446                 {
 447                     if (null != propertyValue)
 448                     {
 449                         propertyValue.Get(shadowOffset);
 450                         x = shadowOffset.X;
 451                         y = shadowOffset.Y;
 452                     }
 453                 }
 454                 return new Vector2(OnShadowOffsetChanged, x, y);
 455             }
 456             set
 457             {
 458                 using (var map = new PropertyMap())
 459                 {
 460                     map.Add("offset", value);
 461
 462                     var shadowMap = Shadow;
 463                     shadowMap.Merge(map);
 464
 465                     SetValue(ShadowProperty, shadowMap);
 466                     NotifyPropertyChanged();
 467                 }
 468             }
 469         }
 470
 471         /// <summary>
 472         /// The ShadowColor property.<br />
 473         /// The color of a drop shadow.<br />
 474         /// </summary>
 475         /// <since_tizen> 3 </since_tizen>
 476         /// <remarks>
 477         /// Deprecated.(API Level 6) Use Shadow instead.
 478         /// The property cascade chaining set is possible. For example, this (textLabel.ShadowColor.X = 0.1f;) is possible.
 479         /// </remarks>
 480         [Obsolete("Please do not use this ShadowColor(Deprecated). Please use Shadow instead.")]
 481         public Vector4 ShadowColor
 482         {
 483             get
 484             {
 485                 return GetValue(ShadowColorProperty) as Vector4;
 486             }
 487             set
 488             {
 489                 SetValue(ShadowColorProperty, value);
 490             }
 491         }
 492
 493         private Vector4 InternalShadowColor
 494         {
 495             get
 496             {
 497                 float x = 0.0f, y = 0.0f, z = 0.0f, w = 0.0f;
 498                 using (var propertyValue = Shadow.Find(TextLabel.Property.SHADOW, "color"))
 499                 using (var shadowColor = new Vector4())
 500                 {
 501                     if (null != propertyValue)
 502                     {
 503                         propertyValue.Get(shadowColor);
 504                         x = shadowColor.X;
 505                         y = shadowColor.Y;
 506                         z = shadowColor.Z;
 507                         w = shadowColor.W;
 508                     }
 509                 }
 510                 return new Vector4(OnShadowColorChanged, x, y, z, w);
 511             }
 512             set
 513             {
 514                 using (var map = new PropertyMap())
 515                 {
 516                     map.Add("color", value);
 517                     var shadowMap = Shadow;
 518                     shadowMap.Merge(map);
 519                     SetValue(ShadowProperty, shadowMap);
 520                     NotifyPropertyChanged();
 521                 }
 522             }
 523         }
 524
 525         /// <summary>
 526         /// The UnderlineEnabled property.<br />
 527         /// The underline enabled flag.<br />
 528         /// </summary>
 529         /// <since_tizen> 3 </since_tizen>
 530         /// <remarks>
 531         /// Deprecated.(API Level 6) Use Underline instead.
 532         /// </remarks>
 533         [Obsolete("Please do not use this UnderlineEnabled(Deprecated). Please use Underline instead.")]
 534         public bool UnderlineEnabled
 535         {
 536             get
 537             {
 538                 return (bool)GetValue(UnderlineEnabledProperty);
 539             }
 540             set
 541             {
 542                 SetValue(UnderlineEnabledProperty, value);
 543             }
 544         }
 545
 546         private bool InternalUnderlineEnabled
 547         {
 548             get
 549             {
 550                 bool underlineEnabled = false;
 551                 using (var propertyValue = Underline.Find(TextLabel.Property.UNDERLINE, "enable"))
 552                 {
 553                     propertyValue.Get(out underlineEnabled);
 554                 }
 555                 return underlineEnabled;
 556             }
 557             set
 558             {
 559                 using (var map = new PropertyMap())
 560                 {
 561                     map.Add("enable", value);
 562                     var undelineMap = Underline;
 563                     undelineMap.Merge(map);
 564                     SetValue(UnderlineProperty, undelineMap);
 565                     NotifyPropertyChanged();
 566                 }
 567             }
 568         }
 569
 570         /// <summary>
 571         /// The UnderlineColor property.<br />
 572         /// Overrides the underline height from font metrics.<br />
 573         /// </summary>
 574         /// <since_tizen> 3 </since_tizen>
 575         /// <remarks>
 576         /// Deprecated.(API Level 6) Use Underline instead.
 577         /// The property cascade chaining set is possible. For example, this (textLabel.UnderlineColor.X = 0.1f;) is possible.
 578         /// </remarks>
 579         [Obsolete("Please do not use this UnderlineColor(Deprecated). Please use Underline instead.")]
 580         public Vector4 UnderlineColor
 581         {
 582             get
 583             {
 584                 return GetValue(UnderlineColorProperty) as Vector4;
 585             }
 586             set
 587             {
 588                 SetValue(UnderlineColorProperty, value);
 589             }
 590         }
 591
 592         private Vector4 InternalUnderlineColor
 593         {
 594             get
 595             {
 596                 float x = 0.0f, y = 0.0f, z = 0.0f, w = 0.0f;
 597                 using (var propertyValue = Underline.Find(TextLabel.Property.UNDERLINE, "color"))
 598                 using (var underlineColor = new Vector4())
 599                 {
 600                     if (null != propertyValue)
 601                     {
 602                         propertyValue.Get(underlineColor);
 603                         x = underlineColor.X;
 604                         y = underlineColor.Y;
 605                         z = underlineColor.Z;
 606                         w = underlineColor.W;
 607                     }
 608                 }
 609                 return new Vector4(OnUnderlineColorChanged, x, y, z, w);
 610             }
 611             set
 612             {
 613                 using (var map = new PropertyMap())
 614                 {
 615                     map.Add("color", value);
 616                     var undelineMap = Underline;
 617                     undelineMap.Merge(map);
 618                     SetValue(UnderlineProperty, undelineMap);
 619                     NotifyPropertyChanged();
 620                 }
 621             }
 622         }
 623
 624         /// <summary>
 625         /// The UnderlineHeight property.<br />
 626         /// Overrides the underline height from font metrics.<br />
 627         /// </summary>
 628         /// <since_tizen> 3 </since_tizen>
 629         /// <remarks>
 630         /// Deprecated.(API Level 6) Use Underline instead.
 631         /// </remarks>
 632         [Obsolete("Please do not use this UnderlineHeight(Deprecated). Please use Underline instead.")]
 633         public float UnderlineHeight
 634         {
 635             get
 636             {
 637                 return (float)GetValue(UnderlineHeightProperty);
 638             }
 639             set
 640             {
 641                 SetValue(UnderlineHeightProperty, value);
 642             }
 643         }
 644
 645         private float InternalUnderlineHeight
 646         {
 647             get
 648             {
 649                 float underlineHeight = 0.0f;
 650                 using (var propertyValue = Underline.Find(TextLabel.Property.UNDERLINE, "height"))
 651                 {
 652                     if (null != propertyValue)
 653                     {
 654                         propertyValue.Get(out underlineHeight);
 655                     }
 656                 }
 657                 return underlineHeight;
 658             }
 659             set
 660             {
 661                 using (var map = new PropertyMap())
 662                 {
 663                     map.Add("height", value);
 664                     var undelineMap = Underline;
 665                     undelineMap.Merge(map);
 666                     SetValue(UnderlineProperty, undelineMap);
 667                     NotifyPropertyChanged();
 668                 }
 669             }
 670         }
 671
 672         /// <summary>
 673         /// The EnableMarkup property.<br />
 674         /// Whether the mark-up processing is enabled.<br />
 675         /// </summary>
 676         /// <since_tizen> 3 </since_tizen>
 677         public bool EnableMarkup
 678         {
 679             get
 680             {
 681                 return (bool)GetValue(EnableMarkupProperty);
 682             }
 683             set
 684             {
 685                 SetValue(EnableMarkupProperty, value);
 686                 NotifyPropertyChanged();
 687             }
 688         }
 689
 690         /// <summary>
 691         /// The EnableAutoScroll property.<br />
 692         /// Starts or stops auto scrolling.<br />
 693         /// </summary>
 694         /// <since_tizen> 3 </since_tizen>
 695         public bool EnableAutoScroll
 696         {
 697             get
 698             {
 699                 return (bool)GetValue(EnableAutoScrollProperty);
 700             }
 701             set
 702             {
 703                 SetValue(EnableAutoScrollProperty, value);
 704                 NotifyPropertyChanged();
 705             }
 706         }
 707
 708         /// <summary>
 709         /// The AutoScrollSpeed property.<br />
 710         /// Sets the speed of scrolling in pixels per second.<br />
 711         /// </summary>
 712         /// <since_tizen> 3 </since_tizen>
 713         public int AutoScrollSpeed
 714         {
 715             get
 716             {
 717                 return (int)GetValue(AutoScrollSpeedProperty);
 718             }
 719             set
 720             {
 721                 SetValue(AutoScrollSpeedProperty, value);
 722                 NotifyPropertyChanged();
 723             }
 724         }
 725
 726         /// <summary>
 727         /// The AutoScrollLoopCount property.<br />
 728         /// Number of complete loops when scrolling enabled.<br />
 729         /// </summary>
 730         /// <since_tizen> 3 </since_tizen>
 731         public int AutoScrollLoopCount
 732         {
 733             get
 734             {
 735                 return (int)GetValue(AutoScrollLoopCountProperty);
 736             }
 737             set
 738             {
 739                 SetValue(AutoScrollLoopCountProperty, value);
 740                 NotifyPropertyChanged();
 741             }
 742         }
 743
 744         /// <summary>
 745         /// The AutoScrollGap property.<br />
 746         /// Gap before scrolling wraps.<br />
 747         /// </summary>
 748         /// <since_tizen> 3 </since_tizen>
 749         public float AutoScrollGap
 750         {
 751             get
 752             {
 753                 return (float)GetValue(AutoScrollGapProperty);
 754             }
 755             set
 756             {
 757                 SetValue(AutoScrollGapProperty, value);
 758                 NotifyPropertyChanged();
 759             }
 760         }
 761
 762         /// <summary>
 763         /// The LineSpacing property.<br />
 764         /// The default extra space between lines in points.<br />
 765         /// </summary>
 766         /// <since_tizen> 3 </since_tizen>
 767         public float LineSpacing
 768         {
 769             get
 770             {
 771                 return (float)GetValue(LineSpacingProperty);
 772             }
 773             set
 774             {
 775                 SetValue(LineSpacingProperty, value);
 776                 NotifyPropertyChanged();
 777             }
 778         }
 779
 780         /// <summary>
 781         /// The Underline property.<br />
 782         /// The default underline parameters.<br />
 783         /// The underline map contains the following keys :<br />
 784         /// <list type="table">
 785         /// <item><term>enable (bool)</term><description>Whether the underline is enabled (the default value is false)</description></item>
 786         /// <item><term>color (Color)</term><description>The color of the underline (If not provided then the color of the text is used)</description></item>
 787         /// <item><term>height (float)</term><description>The height in pixels of the underline (the default value is 1.f)</description></item>
 788         /// </list>
 789         /// </summary>
 790         /// <since_tizen> 3 </since_tizen>
 791         [System.Diagnostics.CodeAnalysis.SuppressMessage("Naming", "CA1721: Property names should not match get methods")]
 792         public PropertyMap Underline
 793         {
 794             get
 795             {
 796                 return (PropertyMap)GetValue(UnderlineProperty);
 797             }
 798             set
 799             {
 800                 SetValue(UnderlineProperty, value);
 801                 NotifyPropertyChanged();
 802             }
 803         }
 804
 805         /// <summary>
 806         /// Set Underline to TextLabel. <br />
 807         /// </summary>
 808         /// <param name="underline">The Underline</param>
 809         /// <remarks>
 810         /// SetUnderline specifies the underline of the text through <see cref="Tizen.NUI.Text.Underline"/>. <br />
 811         /// </remarks>
 812         /// <example>
 813         /// The following example demonstrates how to use the SetUnderline method.
 814         /// <code>
 815         /// var underline = new Tizen.NUI.Text.Underline();
 816         /// underline.Enable = true;
 817         /// underline.Color = new Color("#3498DB");
 818         /// underline.Height = 2.0f;
 819         /// label.SetUnderline(underline);
 820         /// </code>
 821         /// </example>
 822         [EditorBrowsable(EditorBrowsableState.Never)]
 823         public void SetUnderline(Underline underline)
 824         {
 825             using (var underlineMap = TextMapHelper.GetUnderlineMap(underline))
 826             {
 827                 SetValue(UnderlineProperty, underlineMap);
 828             }
 829         }
 830
 831         /// <summary>
 832         /// Get Underline from TextLabel. <br />
 833         /// </summary>
 834         /// <returns>The Underline</returns>
 835         /// <remarks>
 836         /// <see cref="Tizen.NUI.Text.Underline"/>
 837         /// </remarks>
 838         [EditorBrowsable(EditorBrowsableState.Never)]
 839         public Underline GetUnderline()
 840         {
 841             Underline underline;
 842             using (var underlineMap = (PropertyMap)GetValue(UnderlineProperty))
 843             {
 844                 underline = TextMapHelper.GetUnderlineStruct(underlineMap);
 845             }
 846             return underline;
 847         }
 848
 849         /// <summary>
 850         /// The Shadow property.<br />
 851         /// The default shadow parameters.<br />
 852         /// The shadow map contains the following keys :<br />
 853         /// <list type="table">
 854         /// <item><term>color (Color)</term><description>The color of the shadow (the default color is Color.Black)</description></item>
 855         /// <item><term>offset (Vector2)</term><description>The offset in pixels of the shadow (If not provided then the shadow is not enabled)</description></item>
 856         /// <item><term>blurRadius (float)</term><description>The radius of the Gaussian blur for the soft shadow (If not provided then the soft shadow is not enabled)</description></item>
 857         /// </list>
 858         /// </summary>
 859         /// <since_tizen> 3 </since_tizen>
 860         [System.Diagnostics.CodeAnalysis.SuppressMessage("Naming", "CA1721: Property names should not match get methods")]
 861         public PropertyMap Shadow
 862         {
 863             get
 864             {
 865                 return (PropertyMap)GetValue(ShadowProperty);
 866             }
 867             set
 868             {
 869                 SetValue(ShadowProperty, value);
 870                 NotifyPropertyChanged();
 871             }
 872         }
 873
 874         /// <summary>
 875         /// Set Shadow to TextLabel. <br />
 876         /// </summary>
 877         /// <param name="shadow">The Shadow</param>
 878         /// <remarks>
 879         /// SetShadow specifies the shadow of the text through <see cref="Tizen.NUI.Text.Shadow"/>. <br />
 880         /// </remarks>
 881         /// <example>
 882         /// The following example demonstrates how to use the SetShadow method.
 883         /// <code>
 884         /// var shadow = new Tizen.NUI.Text.Shadow();
 885         /// shadow.Offset = new Vector2(3, 3);
 886         /// shadow.Color = new Color("#F1C40F");
 887         /// shadow.BlurRadius = 4.0f;
 888         /// label.SetShadow(shadow);
 889         /// </code>
 890         /// </example>
 891         [EditorBrowsable(EditorBrowsableState.Never)]
 892         public void SetShadow(Tizen.NUI.Text.Shadow shadow)
 893         {
 894             using (var shadowMap = TextMapHelper.GetShadowMap(shadow))
 895             {
 896                 SetValue(ShadowProperty, shadowMap);
 897             }
 898         }
 899
 900         /// <summary>
 901         /// Get Shadow from TextLabel. <br />
 902         /// </summary>
 903         /// <returns>The Shadow</returns>
 904         /// <remarks>
 905         /// <see cref="Tizen.NUI.Text.Shadow"/>
 906         /// </remarks>
 907         [EditorBrowsable(EditorBrowsableState.Never)]
 908         public Tizen.NUI.Text.Shadow GetShadow()
 909         {
 910             Tizen.NUI.Text.Shadow shadow;
 911             using (var shadowMap = (PropertyMap)GetValue(ShadowProperty))
 912             {
 913                 shadow = TextMapHelper.GetShadowStruct(shadowMap);
 914             }
 915             return shadow;
 916         }
 917
 918         /// <summary>
 919         /// Describes a text shadow for a TextLabel.
 920         /// It is null by default.
 921         /// </summary>
 922         [EditorBrowsable(EditorBrowsableState.Never)]
 923         public TextShadow TextShadow
 924         {
 925             get
 926             {
 927                 return (TextShadow)GetValue(TextShadowProperty);
 928             }
 929             set
 930             {
 931                 SetValue(TextShadowProperty, value);
 932                 NotifyPropertyChanged();
 933             }
 934         }
 935
 936         /// <summary>
 937         /// The Emboss property.<br />
 938         /// The default emboss parameters.<br />
 939         /// </summary>
 940         /// <since_tizen> 3 </since_tizen>
 941         public string Emboss
 942         {
 943             get
 944             {
 945                 return (string)GetValue(EmbossProperty);
 946             }
 947             set
 948             {
 949                 SetValue(EmbossProperty, value);
 950                 NotifyPropertyChanged();
 951             }
 952         }
 953
 954         /// <summary>
 955         /// The Outline property.<br />
 956         /// The default outline parameters.<br />
 957         /// The outline map contains the following keys :<br />
 958         /// <list type="table">
 959         /// <item><term>color (Color)</term><description>The color of the outline (the default color is Color.White)</description></item>
 960         /// <item><term>width (float)</term><description>The width in pixels of the outline (If not provided then the outline is not enabled)</description></item>
 961         /// </list>
 962         /// </summary>
 963         /// <since_tizen> 3 </since_tizen>
 964         [System.Diagnostics.CodeAnalysis.SuppressMessage("Naming", "CA1721: Property names should not match get methods")]
 965         public PropertyMap Outline
 966         {
 967             get
 968             {
 969                 return (PropertyMap)GetValue(OutlineProperty);
 970             }
 971             set
 972             {
 973                 SetValue(OutlineProperty, value);
 974                 NotifyPropertyChanged();
 975             }
 976         }
 977
 978         /// <summary>
 979         /// Set Outline to TextLabel. <br />
 980         /// </summary>
 981         /// <param name="outline">The Outline</param>
 982         /// <remarks>
 983         /// SetOutline specifies the outline of the text through <see cref="Tizen.NUI.Text.Outline"/>. <br />
 984         /// </remarks>
 985         /// <example>
 986         /// The following example demonstrates how to use the SetOutline method.
 987         /// <code>
 988         /// var outline = new Tizen.NUI.Text.Outline();
 989         /// outline.Width = 2.0f;
 990         /// outline.Color = new Color("#45B39D");
 991         /// label.SetOutline(outline);
 992         /// </code>
 993         /// </example>
 994         [EditorBrowsable(EditorBrowsableState.Never)]
 995         public void SetOutline(Outline outline)
 996         {
 997             using (var outlineMap = TextMapHelper.GetOutlineMap(outline))
 998             {
 999                 SetValue(OutlineProperty, outlineMap);
1000             }
1001         }
1002
1003         /// <summary>
1004         /// Get Outline from TextLabel. <br />
1005         /// </summary>
1006         /// <returns>The Outline</returns>
1007         /// <remarks>
1008         /// <see cref="Tizen.NUI.Text.Outline"/>
1009         /// </remarks>
1010         [EditorBrowsable(EditorBrowsableState.Never)]
1011         public Outline GetOutline()
1012         {
1013             Outline outline;
1014             using (var outlineMap = (PropertyMap)GetValue(OutlineProperty))
1015             {
1016                 outline = TextMapHelper.GetOutlineStruct(outlineMap);
1017             }
1018             return outline;
1019         }
1020
1021         /// <summary>
1022         /// The PixelSize property.<br />
1023         /// The size of font in pixels.<br />
1024         /// </summary>
1025         /// <since_tizen> 3 </since_tizen>
1026         public float PixelSize
1027         {
1028             get
1029             {
1030                 return (float)GetValue(PixelSizeProperty);
1031             }
1032             set
1033             {
1034                 SetValue(PixelSizeProperty, value);
1035                 NotifyPropertyChanged();
1036             }
1037         }
1038
1039         /// <summary>
1040         /// The Ellipsis property.<br />
1041         /// Enable or disable the ellipsis.<br />
1042         /// </summary>
1043         /// <since_tizen> 3 </since_tizen>
1044         public bool Ellipsis
1045         {
1046             get
1047             {
1048                 return (bool)GetValue(EllipsisProperty);
1049             }
1050             set
1051             {
1052                 SetValue(EllipsisProperty, value);
1053                 NotifyPropertyChanged();
1054             }
1055         }
1056
1057         /// <summary>
1058         /// The ellipsis position of the text.
1059         /// Specifies which portion of the text should be replaced with an ellipsis when the text size exceeds the layout size.<br />
1060         /// </summary>
1061         /// <since_tizen> 9 </since_tizen>
1062         public EllipsisPosition EllipsisPosition
1063         {
1064             get
1065             {
1066                 return (EllipsisPosition)GetValue(EllipsisPositionProperty);
1067             }
1068             set
1069             {
1070                 SetValue(EllipsisPositionProperty, value);
1071                 NotifyPropertyChanged();
1072             }
1073         }
1074
1075         /// <summary>
1076         /// The AutoScrollLoopDelay property.<br />
1077         /// The amount of time to delay the starting time of auto scrolling and further loops.<br />
1078         /// </summary>
1079         /// <since_tizen> 3 </since_tizen>
1080         public float AutoScrollLoopDelay
1081         {
1082             get
1083             {
1084                 return (float)GetValue(AutoScrollLoopDelayProperty);
1085             }
1086             set
1087             {
1088                 SetValue(AutoScrollLoopDelayProperty, value);
1089                 NotifyPropertyChanged();
1090             }
1091         }
1092
1093         /// <summary>
1094         /// The AutoScrollStopMode property.<br />
1095         /// The auto scrolling stop behaviour.<br />
1096         /// The default value is AutoScrollStopMode.FinishLoop. <br />
1097         /// </summary>
1098         /// <since_tizen> 3 </since_tizen>
1099         public AutoScrollStopMode AutoScrollStopMode
1100         {
1101             get
1102             {
1103                 return (AutoScrollStopMode)GetValue(AutoScrollStopModeProperty);
1104             }
1105             set
1106             {
1107                 SetValue(AutoScrollStopModeProperty, value);
1108                 NotifyPropertyChanged();
1109             }
1110         }
1111
1112         /// <summary>
1113         /// The line count of the text.
1114         /// </summary>
1115         /// <since_tizen> 3 </since_tizen>
1116         public int LineCount
1117         {
1118             get
1119             {
1120                 int lineCount = 0;
1121                 using (var propertyValue = GetProperty(TextLabel.Property.LineCount))
1122                 {
1123                     propertyValue.Get(out lineCount);
1124                 }
1125                 return lineCount;
1126             }
1127         }
1128
1129         /// <summary>
1130         /// The LineWrapMode property.<br />
1131         /// line wrap mode when the text lines over layout width.<br />
1132         /// </summary>
1133         /// <since_tizen> 4 </since_tizen>
1134         public LineWrapMode LineWrapMode
1135         {
1136             get
1137             {
1138                 return (LineWrapMode)GetValue(LineWrapModeProperty);
1139             }
1140             set
1141             {
1142                 SetValue(LineWrapModeProperty, value);
1143                 NotifyPropertyChanged();
1144             }
1145         }
1146
1147         /// <summary>
1148         /// The direction of the text such as left to right or right to left.
1149         /// </summary>
1150         /// This will be public opened in next release of tizen after ACR done. Before ACR, it is used as HiddenAPI (InhouseAPI).
1151         [EditorBrowsable(EditorBrowsableState.Never)]
1152         public TextDirection TextDirection
1153         {
1154             get
1155             {
1156                 int textDirection = 0;
1157                 using (var propertyValue = GetProperty(TextLabel.Property.TextDirection))
1158                 {
1159                     propertyValue.Get(out textDirection);
1160                 }
1161                 return (TextDirection)textDirection;
1162             }
1163         }
1164
1165         /// <summary>
1166         /// The vertical line alignment of the text.
1167         /// </summary>
1168         /// This will be public opened in next release of tizen after ACR done. Before ACR, it is used as HiddenAPI (InhouseAPI).
1169         [EditorBrowsable(EditorBrowsableState.Never)]
1170         public VerticalLineAlignment VerticalLineAlignment
1171         {
1172             get
1173             {
1174                 return (VerticalLineAlignment)GetValue(VerticalLineAlignmentProperty);
1175             }
1176             set
1177             {
1178                 SetValue(VerticalLineAlignmentProperty, value);
1179                 NotifyPropertyChanged();
1180             }
1181         }
1182
1183         /// <summary>
1184         /// The text alignment to match the direction of the system language.
1185         /// </summary>
1186         /// <since_tizen> 6 </since_tizen>
1187         public bool MatchSystemLanguageDirection
1188         {
1189             get
1190             {
1191                 return (bool)GetValue(MatchSystemLanguageDirectionProperty);
1192             }
1193             set
1194             {
1195                 SetValue(MatchSystemLanguageDirectionProperty, value);
1196                 NotifyPropertyChanged();
1197             }
1198         }
1199
1200         /// <summary>
1201         /// The text fit parameters.<br />
1202         /// The textFit map contains the following keys :<br />
1203         /// <list type="table">
1204         /// <item><term>enable (bool)</term><description>True to enable the text fit or false to disable (the default value is false)</description></item>
1205         /// <item><term>minSize (float)</term><description>Minimum Size for text fit (the default value is 10.f)</description></item>
1206         /// <item><term>maxSize (float)</term><description>Maximum Size for text fit (the default value is 100.f)</description></item>
1207         /// <item><term>stepSize (float)</term><description>Step Size for font increase (the default value is 1.f)</description></item>
1208         /// <item><term>fontSize (string)</term><description>The size type of font, You can choose between "pointSize" or "pixelSize". (the default value is "pointSize")</description></item>
1209         /// </list>
1210         /// </summary>
1211         /// This will be public opened in next release of tizen after ACR done. Before ACR, it is used as HiddenAPI (InhouseAPI).
1212         [EditorBrowsable(EditorBrowsableState.Never)]
1213         [System.Diagnostics.CodeAnalysis.SuppressMessage("Naming", "CA1721: Property names should not match get methods")]
1214         public PropertyMap TextFit
1215         {
1216             get
1217             {
1218                 return (PropertyMap)GetValue(TextFitProperty);
1219             }
1220             set
1221             {
1222                 SetValue(TextFitProperty, value);
1223                 NotifyPropertyChanged();
1224             }
1225         }
1226
1227         /// <summary>
1228         /// Set TextFit to TextLabel. <br />
1229         /// </summary>
1230         /// <param name="textFit">The TextFit</param>
1231         /// <remarks>
1232         /// SetTextFit specifies the textFit of the text through <see cref="Tizen.NUI.Text.TextFit"/>. <br />
1233         /// </remarks>
1234         /// <example>
1235         /// The following example demonstrates how to use the SetTextFit method.
1236         /// <code>
1237         /// var textFit = new Tizen.NUI.Text.TextFit();
1238         /// textFit.Enable = true;
1239         /// textFit.MinSize = 10.0f;
1240         /// textFit.MaxSize = 100.0f;
1241         /// textFit.StepSize = 5.0f;
1242         /// textFit.FontSizeType = FontSizeType.PointSize;
1243         /// label.SetTextFit(textFit);
1244         /// </code>
1245         /// </example>
1246         [EditorBrowsable(EditorBrowsableState.Never)]
1247         public void SetTextFit(TextFit textFit)
1248         {
1249             using (var textFitMap = TextMapHelper.GetTextFitMap(textFit))
1250             {
1251                 SetValue(TextFitProperty, textFitMap);
1252             }
1253         }
1254
1255         /// <summary>
1256         /// Get TextFit from TextLabel. <br />
1257         /// </summary>
1258         /// <returns>The TextFit</returns>
1259         /// <remarks>
1260         /// TextFit is always returned based on PointSize. <br />
1261         /// If the user sets FontSizeType to PixelSize, then MinSize, MaxSize, and StepSize are converted based on PointSize and returned. <br />
1262         /// <see cref="Tizen.NUI.Text.TextFit"/>
1263         /// </remarks>
1264         [EditorBrowsable(EditorBrowsableState.Never)]
1265         public TextFit GetTextFit()
1266         {
1267             TextFit textFit;
1268             using (var textFitMap = (PropertyMap)GetValue(TextFitProperty))
1269             {
1270                 textFit = TextMapHelper.GetTextFitStruct(textFitMap);
1271             }
1272             return textFit;
1273         }
1274
1275         /// <summary>
1276         /// The MinLineSize property.<br />
1277         /// The height of the line in points. <br />
1278         /// If the font size is larger than the line size, it works with the font size. <br />
1279         /// </summary>
1280         /// This will be public opened in next release of tizen after ACR done. Before ACR, it is used as HiddenAPI (InhouseAPI).
1281         [EditorBrowsable(EditorBrowsableState.Never)]
1282         public float MinLineSize
1283         {
1284             get
1285             {
1286                 return (float)GetValue(MinLineSizeProperty);
1287             }
1288             set
1289             {
1290                 SetValue(MinLineSizeProperty, value);
1291                 NotifyPropertyChanged();
1292             }
1293         }
1294
1295         /// <summary>
1296         /// The FontSizeScale property for scaling the specified font size up or down. <br />
1297         /// The default value is 1.0. <br />
1298         /// The given font size scale value is used for multiplying the specified font size before querying fonts. <br />
1299         /// If FontSizeScale.UseSystemSetting, will use the SystemSettings.FontSize internally. <br />
1300         /// </summary>
1301         /// <since_tizen> 9 </since_tizen>
1302         public float FontSizeScale
1303         {
1304             get
1305             {
1306                 return fontSizeScale;
1307             }
1308             set
1309             {
1310                 float newFontSizeScale;
1311
1312                 if (fontSizeScale == value) return;
1313
1314                 fontSizeScale = value;
1315                 if (fontSizeScale == Tizen.NUI.FontSizeScale.UseSystemSetting)
1316                 {
1317                     SystemSettingsFontSize systemSettingsFontSize;
1318
1319                     try
1320                     {
1321                         systemSettingsFontSize = SystemSettings.FontSize;
1322                     }
1323                     catch (Exception e)
1324                     {
1325                         Console.WriteLine("{0} Exception caught.", e);
1326                         systemSettingsFontSize = SystemSettingsFontSize.Normal;
1327                     }
1328                     newFontSizeScale = TextUtils.GetFontSizeScale(systemSettingsFontSize);
1329                     addFontSizeChangedCallback();
1330                 }
1331                 else
1332                 {
1333                     newFontSizeScale = fontSizeScale;
1334                     removeFontSizeChangedCallback();
1335                 }
1336
1337                 SetValue(FontSizeScaleProperty, newFontSizeScale);
1338                 NotifyPropertyChanged();
1339             }
1340         }
1341
1342         private TextLabelSelectorData EnsureSelectorData() => selectorData ?? (selectorData = new TextLabelSelectorData());
1343
1344         /// <summary>
1345         /// Downcasts a handle to textLabel handle
1346         /// </summary>
1347         /// <param name="handle"></param>
1348         /// <returns></returns>
1349         /// <exception cref="ArgumentNullException"> Thrown when handle is null. </exception>
1350         /// <since_tizen> 3 </since_tizen>
1351         /// Please do not use! this will be deprecated!
1352         /// Instead please use as keyword.
1353         [Obsolete("Please do not use! This will be deprecated! Please use as keyword instead! " +
1354             "Like: " +
1355             "BaseHandle handle = new TextLabel(\"Hello World!\"); " +
1356             "TextLabel label = handle as TextLabel")]
1357         [EditorBrowsable(EditorBrowsableState.Never)]
1358         public static TextLabel DownCast(BaseHandle handle)
1359         {
1360             if (null == handle)
1361             {
1362                 throw new ArgumentNullException(nameof(handle));
1363             }
1364             TextLabel ret = Registry.GetManagedBaseHandleFromNativePtr(handle) as TextLabel;
1365             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1366             return ret;
1367         }
1368
1369         /// <inheritdoc/>
1370         [EditorBrowsable(EditorBrowsableState.Never)]
1371         protected override void Dispose(DisposeTypes type)
1372         {
1373             if (disposed)
1374             {
1375                 return;
1376             }
1377
1378             if (systemlangTextFlag)
1379             {
1380                 SystemSettings.LocaleLanguageChanged -= SystemSettings_LocaleLanguageChanged;
1381             }
1382
1383             removeFontSizeChangedCallback();
1384
1385             if (type == DisposeTypes.Explicit)
1386             {
1387                 //Called by User
1388                 //Release your own managed resources here.
1389                 //You should release all of your own disposable objects here.
1390                 selectorData?.Reset(this);
1391             }
1392
1393             if (this.HasBody())
1394             {
1395                 if (textLabelTextFitChangedCallbackDelegate != null)
1396                 {
1397                     TextFitChangedSignal().Disconnect(textLabelTextFitChangedCallbackDelegate);
1398                 }
1399             }
1400
1401             base.Dispose(type);
1402         }
1403
1404         /// This will not be public opened.
1405         [EditorBrowsable(EditorBrowsableState.Never)]
1406         protected override void ReleaseSwigCPtr(System.Runtime.InteropServices.HandleRef swigCPtr)
1407         {
1408             Interop.TextLabel.DeleteTextLabel(swigCPtr);
1409         }
1410
1411         /// <summary>
1412         /// Get attribues, it is abstract function and must be override.
1413         /// </summary>
1414         [EditorBrowsable(EditorBrowsableState.Never)]
1415         protected override ViewStyle CreateViewStyle()
1416         {
1417             return new TextLabelStyle();
1418         }
1419
1420         internal override LayoutItem CreateDefaultLayout()
1421         {
1422             return new TextLayout();
1423         }
1424
1425         /// <summary>
1426         /// Invoked whenever the binding context of the textlabel changes. Implement this method to add class handling for this event.
1427         /// </summary>
1428         protected override void OnBindingContextChanged()
1429         {
1430             base.OnBindingContextChanged();
1431         }
1432
1433         private void SystemSettings_LocaleLanguageChanged(object sender, LocaleLanguageChangedEventArgs e)
1434         {
1435             Text = NUIApplication.MultilingualResourceManager?.GetString(textLabelSid, new CultureInfo(e.Value.Replace("_", "-")));
1436         }
1437
1438         private void SystemSettingsFontSizeChanged(object sender, FontSizeChangedEventArgs e)
1439         {
1440             float newFontSizeScale = TextUtils.GetFontSizeScale(e.Value);
1441             SetValue(FontSizeScaleProperty, newFontSizeScale);
1442         }
1443
1444         private void addFontSizeChangedCallback()
1445         {
1446             if (hasFontSizeChangedCallback != true)
1447             {
1448                 try
1449                 {
1450                     SystemSettings.FontSizeChanged += SystemSettingsFontSizeChanged;
1451                     hasFontSizeChangedCallback = true;
1452                 }
1453                 catch (Exception e)
1454                 {
1455                     Console.WriteLine("{0} Exception caught.", e);
1456                     hasFontSizeChangedCallback = false;
1457                 }
1458             }
1459         }
1460
1461         private void removeFontSizeChangedCallback()
1462         {
1463             if (hasFontSizeChangedCallback == true)
1464             {
1465                 try
1466                 {
1467                     SystemSettings.FontSizeChanged -= SystemSettingsFontSizeChanged;
1468                     hasFontSizeChangedCallback = false;
1469                 }
1470                 catch (Exception e)
1471                 {
1472                     Console.WriteLine("{0} Exception caught.", e);
1473                     hasFontSizeChangedCallback = true;
1474                 }
1475             }
1476         }
1477
1478         private void RequestLayout()
1479         {
1480             Layout?.RequestLayout();
1481         }
1482
1483         internal new class Property
1484         {
1485             internal static readonly int TEXT = Interop.TextLabel.TextGet();
1486             internal static readonly int FontFamily = Interop.TextLabel.FontFamilyGet();
1487             internal static readonly int FontStyle = Interop.TextLabel.FontStyleGet();
1488             internal static readonly int PointSize = Interop.TextLabel.PointSizeGet();
1489             internal static readonly int MultiLine = Interop.TextLabel.MultiLineGet();
1490             internal static readonly int HorizontalAlignment = Interop.TextLabel.HorizontalAlignmentGet();
1491             internal static readonly int VerticalAlignment = Interop.TextLabel.VerticalAlignmentGet();
1492             internal static readonly int TextColor = Interop.TextLabel.TextColorGet();
1493             internal static readonly int EnableMarkup = Interop.TextLabel.EnableMarkupGet();
1494             internal static readonly int EnableAutoScroll = Interop.TextLabel.EnableAutoScrollGet();
1495             internal static readonly int AutoScrollSpeed = Interop.TextLabel.AutoScrollSpeedGet();
1496             internal static readonly int AutoScrollLoopCount = Interop.TextLabel.AutoScrollLoopCountGet();
1497             internal static readonly int AutoScrollGap = Interop.TextLabel.AutoScrollGapGet();
1498             internal static readonly int LineSpacing = Interop.TextLabel.LineSpacingGet();
1499             internal static readonly int UNDERLINE = Interop.TextLabel.UnderlineGet();
1500             internal static readonly int SHADOW = Interop.TextLabel.ShadowGet();
1501             internal static readonly int EMBOSS = Interop.TextLabel.EmbossGet();
1502             internal static readonly int OUTLINE = Interop.TextLabel.OutlineGet();
1503             internal static readonly int PixelSize = Interop.TextLabel.PixelSizeGet();
1504             internal static readonly int ELLIPSIS = Interop.TextLabel.EllipsisGet();
1505             internal static readonly int AutoScrollStopMode = Interop.TextLabel.AutoScrollStopModeGet();
1506             internal static readonly int AutoScrollLoopDelay = Interop.TextLabel.AutoScrollLoopDelayGet();
1507             internal static readonly int LineCount = Interop.TextLabel.LineCountGet();
1508             internal static readonly int LineWrapMode = Interop.TextLabel.LineWrapModeGet();
1509             internal static readonly int TextDirection = Interop.TextLabel.TextDirectionGet();
1510             internal static readonly int VerticalLineAlignment = Interop.TextLabel.VerticalLineAlignmentGet();
1511             internal static readonly int MatchSystemLanguageDirection = Interop.TextLabel.MatchSystemLanguageDirectionGet();
1512             internal static readonly int TextFit = Interop.TextLabel.TextFitGet();
1513             internal static readonly int MinLineSize = Interop.TextLabel.MinLineSizeGet();
1514             internal static readonly int FontSizeScale = Interop.TextLabel.FontSizeScaleGet();
1515             internal static readonly int EllipsisPosition = Interop.TextLabel.EllipsisPositionGet();
1516         }
1517
1518         private void OnShadowColorChanged(float x, float y, float z, float w)
1519         {
1520             ShadowColor = new Vector4(x, y, z, w);
1521         }
1522         private void OnShadowOffsetChanged(float x, float y)
1523         {
1524             ShadowOffset = new Vector2(x, y);
1525         }
1526         private void OnTextColorChanged(float r, float g, float b, float a)
1527         {
1528             TextColor = new Color(r, g, b, a);
1529         }
1530         private void OnUnderlineColorChanged(float x, float y, float z, float w)
1531         {
1532             UnderlineColor = new Vector4(x, y, z, w);
1533         }
1534     }
1535 }