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         /// Create internal layout of TextLabel
 167         /// </summary>
 168         internal LayoutItem CreateTextLayout()
 169         {
 170             return new TextLayout();
 171         }
 172
 173         /// <summary>
 174         /// The TranslatableText property.<br />
 175         /// The text can set the SID value.<br />
 176         /// </summary>
 177         /// <exception cref='ArgumentNullException'>
 178         /// ResourceManager about multilingual is null.
 179         /// </exception>
 180         /// <since_tizen> 4 </since_tizen>
 181         public string TranslatableText
 182         {
 183             get
 184             {
 185                 return (string)GetValue(TranslatableTextProperty);
 186             }
 187             set
 188             {
 189                 SetValue(TranslatableTextProperty, value);
 190             }
 191         }
 192         private string translatableText
 193         {
 194             get
 195             {
 196                 return textLabelSid;
 197             }
 198             set
 199             {
 200                 if (NUIApplication.MultilingualResourceManager == null)
 201                 {
 202                     throw new ArgumentNullException(null, "ResourceManager about multilingual is null");
 203                 }
 204                 string translatableText = null;
 205                 textLabelSid = value;
 206                 translatableText = NUIApplication.MultilingualResourceManager?.GetString(textLabelSid, new CultureInfo(SystemSettings.LocaleLanguage.Replace("_", "-")));
 207                 if (translatableText != null)
 208                 {
 209                     Text = translatableText;
 210                     if (systemlangTextFlag == false)
 211                     {
 212                         SystemSettings.LocaleLanguageChanged += SystemSettings_LocaleLanguageChanged;
 213                         systemlangTextFlag = true;
 214                     }
 215                 }
 216                 else
 217                 {
 218                     Text = "";
 219                 }
 220                 NotifyPropertyChanged();
 221             }
 222         }
 223
 224         /// <summary>
 225         /// The Text property.<br />
 226         /// The text to display in the UTF-8 format.<br />
 227         /// </summary>
 228         /// <since_tizen> 3 </since_tizen>
 229         public string Text
 230         {
 231             get
 232             {
 233                 return (string)GetValue(TextProperty);
 234             }
 235             set
 236             {
 237                 SetValue(TextProperty, value);
 238                 NotifyPropertyChanged();
 239             }
 240         }
 241
 242         /// <summary>
 243         /// The FontFamily property.<br />
 244         /// The requested font family to use.<br />
 245         /// </summary>
 246         /// <since_tizen> 3 </since_tizen>
 247         public string FontFamily
 248         {
 249             get
 250             {
 251                 return (string)GetValue(FontFamilyProperty);
 252             }
 253             set
 254             {
 255                 SetValue(FontFamilyProperty, value);
 256                 NotifyPropertyChanged();
 257             }
 258         }
 259
 260         /// <summary>
 261         /// The FontStyle property.<br />
 262         /// The requested font style to use.<br />
 263         /// The fontStyle map contains the following keys :<br />
 264         /// <list type="table">
 265         /// <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>
 266         /// <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>
 267         /// <item><term>slant (string)</term><description>The slant key defines whether to use italics. (values: normal, roman, italic, oblique)</description></item>
 268         /// </list>
 269         /// </summary>
 270         /// <since_tizen> 3 </since_tizen>
 271         [System.Diagnostics.CodeAnalysis.SuppressMessage("Naming", "CA1721: Property names should not match get methods")]
 272         public PropertyMap FontStyle
 273         {
 274             get
 275             {
 276                 return (PropertyMap)GetValue(FontStyleProperty);
 277             }
 278             set
 279             {
 280                 SetValue(FontStyleProperty, value);
 281                 NotifyPropertyChanged();
 282             }
 283         }
 284
 285         /// <summary>
 286         /// Set FontStyle to TextLabel. <br />
 287         /// </summary>
 288         /// <param name="fontStyle">The FontStyle</param>
 289         /// <remarks>
 290         /// SetFontStyle specifies the requested font style through <see cref="Tizen.NUI.Text.FontStyle"/>. <br />
 291         /// </remarks>
 292         /// <example>
 293         /// The following example demonstrates how to use the SetFontStyle method.
 294         /// <code>
 295         /// var fontStyle = new Tizen.NUI.Text.FontStyle();
 296         /// fontStyle.Width = FontWidthType.Expanded;
 297         /// fontStyle.Weight = FontWeightType.Bold;
 298         /// fontStyle.Slant = FontSlantType.Italic;
 299         /// label.SetFontStyle(fontStyle);
 300         /// </code>
 301         /// </example>
 302         [EditorBrowsable(EditorBrowsableState.Never)]
 303         public void SetFontStyle(FontStyle fontStyle)
 304         {
 305             SetValue(FontStyleProperty, TextUtils.GetFontStyleMap(fontStyle));
 306         }
 307
 308         /// <summary>
 309         /// Get FontStyle from TextLabel. <br />
 310         /// </summary>
 311         /// <returns>The FontStyle</returns>
 312         /// <remarks>
 313         /// <see cref="Tizen.NUI.Text.FontStyle"/>
 314         /// </remarks>
 315         [EditorBrowsable(EditorBrowsableState.Never)]
 316         public FontStyle GetFontStyle()
 317         {
 318             return TextUtils.GetFontStyleStruct((PropertyMap)GetValue(FontStyleProperty));
 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                 Vector2 shadowOffset = new Vector2();
 444                 Shadow.Find(TextLabel.Property.SHADOW, "offset")?.Get(shadowOffset);
 445                 return new Vector2(OnShadowOffsetChanged, shadowOffset.X, shadowOffset.Y);
 446             }
 447             set
 448             {
 449                 PropertyMap temp = new PropertyMap();
 450                 temp.Insert("offset", new PropertyValue(value));
 451
 452                 PropertyMap shadowMap = Shadow;
 453                 shadowMap.Merge(temp);
 454
 455                 SetValue(ShadowProperty, shadowMap);
 456                 NotifyPropertyChanged();
 457             }
 458         }
 459
 460         /// <summary>
 461         /// The ShadowColor property.<br />
 462         /// The color of a drop shadow.<br />
 463         /// </summary>
 464         /// <since_tizen> 3 </since_tizen>
 465         /// <remarks>
 466         /// Deprecated.(API Level 6) Use Shadow instead.
 467         /// The property cascade chaining set is possible. For example, this (textLabel.ShadowColor.X = 0.1f;) is possible.
 468         /// </remarks>
 469         [Obsolete("Please do not use this ShadowColor(Deprecated). Please use Shadow instead.")]
 470         public Vector4 ShadowColor
 471         {
 472             get
 473             {
 474                 return GetValue(ShadowColorProperty) as Vector4;
 475             }
 476             set
 477             {
 478                 SetValue(ShadowColorProperty, value);
 479             }
 480         }
 481
 482         private Vector4 InternalShadowColor
 483         {
 484             get
 485             {
 486                 Vector4 shadowColor = new Vector4();
 487                 Shadow.Find(TextLabel.Property.SHADOW, "color")?.Get(shadowColor);
 488                 return new Vector4(OnShadowColorChanged, shadowColor.X, shadowColor.Y, shadowColor.Z, shadowColor.W);
 489             }
 490             set
 491             {
 492                 PropertyMap temp = new PropertyMap();
 493                 temp.Insert("color", new PropertyValue(value));
 494
 495                 PropertyMap shadowMap = Shadow;
 496                 shadowMap.Merge(temp);
 497
 498                 SetValue(ShadowProperty, shadowMap);
 499                 NotifyPropertyChanged();
 500             }
 501         }
 502
 503         /// <summary>
 504         /// The UnderlineEnabled property.<br />
 505         /// The underline enabled flag.<br />
 506         /// </summary>
 507         /// <since_tizen> 3 </since_tizen>
 508         /// <remarks>
 509         /// Deprecated.(API Level 6) Use Underline instead.
 510         /// </remarks>
 511         [Obsolete("Please do not use this UnderlineEnabled(Deprecated). Please use Underline instead.")]
 512         public bool UnderlineEnabled
 513         {
 514             get
 515             {
 516                 return (bool)GetValue(UnderlineEnabledProperty);
 517             }
 518             set
 519             {
 520                 SetValue(UnderlineEnabledProperty, value);
 521             }
 522         }
 523
 524         private bool InternalUnderlineEnabled
 525         {
 526             get
 527             {
 528                 bool underlineEnabled = false;
 529                 Underline.Find(TextLabel.Property.UNDERLINE, "enable")?.Get(out underlineEnabled);
 530                 return underlineEnabled;
 531             }
 532             set
 533             {
 534                 PropertyMap temp = new PropertyMap();
 535                 temp.Add("enable", new PropertyValue(value));
 536
 537                 PropertyMap undelineMap = Underline;
 538                 undelineMap.Merge(temp);
 539
 540                 SetValue(UnderlineProperty, undelineMap);
 541                 NotifyPropertyChanged();
 542
 543             }
 544         }
 545
 546         /// <summary>
 547         /// The UnderlineColor property.<br />
 548         /// Overrides the underline height from font metrics.<br />
 549         /// </summary>
 550         /// <since_tizen> 3 </since_tizen>
 551         /// <remarks>
 552         /// Deprecated.(API Level 6) Use Underline instead.
 553         /// The property cascade chaining set is possible. For example, this (textLabel.UnderlineColor.X = 0.1f;) is possible.
 554         /// </remarks>
 555         [Obsolete("Please do not use this UnderlineColor(Deprecated). Please use Underline instead.")]
 556         public Vector4 UnderlineColor
 557         {
 558             get
 559             {
 560                 return GetValue(UnderlineColorProperty) as Vector4;
 561             }
 562             set
 563             {
 564                 SetValue(UnderlineColorProperty, value);
 565             }
 566         }
 567
 568         private Vector4 InternalUnderlineColor
 569         {
 570             get
 571             {
 572                 Vector4 underlineColor = new Vector4();
 573                 Underline.Find(TextLabel.Property.UNDERLINE, "color")?.Get(underlineColor);
 574                 return new Vector4(OnUnderlineColorChanged, underlineColor.X, underlineColor.Y, underlineColor.Z, underlineColor.W);
 575             }
 576             set
 577             {
 578                 PropertyMap temp = new PropertyMap();
 579                 temp.Insert("color", new PropertyValue(value));
 580
 581                 PropertyMap undelineMap = Underline;
 582                 undelineMap.Merge(temp);
 583
 584                 SetValue(UnderlineProperty, undelineMap);
 585                 NotifyPropertyChanged();
 586             }
 587         }
 588
 589         /// <summary>
 590         /// The UnderlineHeight property.<br />
 591         /// Overrides the underline height from font metrics.<br />
 592         /// </summary>
 593         /// <since_tizen> 3 </since_tizen>
 594         /// <remarks>
 595         /// Deprecated.(API Level 6) Use Underline instead.
 596         /// </remarks>
 597         [Obsolete("Please do not use this UnderlineHeight(Deprecated). Please use Underline instead.")]
 598         public float UnderlineHeight
 599         {
 600             get
 601             {
 602                 return (float)GetValue(UnderlineHeightProperty);
 603             }
 604             set
 605             {
 606                 SetValue(UnderlineHeightProperty, value);
 607             }
 608         }
 609
 610         private float InternalUnderlineHeight
 611         {
 612             get
 613             {
 614                 float underlineHeight = 0.0f;
 615                 Underline.Find(TextLabel.Property.UNDERLINE, "height")?.Get(out underlineHeight);
 616                 return underlineHeight;
 617             }
 618             set
 619             {
 620                 PropertyMap temp = new PropertyMap();
 621                 temp.Insert("height", new PropertyValue(value));
 622
 623                 PropertyMap undelineMap = Underline;
 624                 undelineMap.Merge(temp);
 625
 626                 SetValue(UnderlineProperty, undelineMap);
 627                 NotifyPropertyChanged();
 628             }
 629         }
 630
 631         /// <summary>
 632         /// The EnableMarkup property.<br />
 633         /// Whether the mark-up processing is enabled.<br />
 634         /// </summary>
 635         /// <since_tizen> 3 </since_tizen>
 636         public bool EnableMarkup
 637         {
 638             get
 639             {
 640                 return (bool)GetValue(EnableMarkupProperty);
 641             }
 642             set
 643             {
 644                 SetValue(EnableMarkupProperty, value);
 645                 NotifyPropertyChanged();
 646             }
 647         }
 648
 649         /// <summary>
 650         /// The EnableAutoScroll property.<br />
 651         /// Starts or stops auto scrolling.<br />
 652         /// </summary>
 653         /// <since_tizen> 3 </since_tizen>
 654         public bool EnableAutoScroll
 655         {
 656             get
 657             {
 658                 return (bool)GetValue(EnableAutoScrollProperty);
 659             }
 660             set
 661             {
 662                 SetValue(EnableAutoScrollProperty, value);
 663                 NotifyPropertyChanged();
 664             }
 665         }
 666
 667         /// <summary>
 668         /// The AutoScrollSpeed property.<br />
 669         /// Sets the speed of scrolling in pixels per second.<br />
 670         /// </summary>
 671         /// <since_tizen> 3 </since_tizen>
 672         public int AutoScrollSpeed
 673         {
 674             get
 675             {
 676                 return (int)GetValue(AutoScrollSpeedProperty);
 677             }
 678             set
 679             {
 680                 SetValue(AutoScrollSpeedProperty, value);
 681                 NotifyPropertyChanged();
 682             }
 683         }
 684
 685         /// <summary>
 686         /// The AutoScrollLoopCount property.<br />
 687         /// Number of complete loops when scrolling enabled.<br />
 688         /// </summary>
 689         /// <since_tizen> 3 </since_tizen>
 690         public int AutoScrollLoopCount
 691         {
 692             get
 693             {
 694                 return (int)GetValue(AutoScrollLoopCountProperty);
 695             }
 696             set
 697             {
 698                 SetValue(AutoScrollLoopCountProperty, value);
 699                 NotifyPropertyChanged();
 700             }
 701         }
 702
 703         /// <summary>
 704         /// The AutoScrollGap property.<br />
 705         /// Gap before scrolling wraps.<br />
 706         /// </summary>
 707         /// <since_tizen> 3 </since_tizen>
 708         public float AutoScrollGap
 709         {
 710             get
 711             {
 712                 return (float)GetValue(AutoScrollGapProperty);
 713             }
 714             set
 715             {
 716                 SetValue(AutoScrollGapProperty, value);
 717                 NotifyPropertyChanged();
 718             }
 719         }
 720
 721         /// <summary>
 722         /// The LineSpacing property.<br />
 723         /// The default extra space between lines in points.<br />
 724         /// </summary>
 725         /// <since_tizen> 3 </since_tizen>
 726         public float LineSpacing
 727         {
 728             get
 729             {
 730                 return (float)GetValue(LineSpacingProperty);
 731             }
 732             set
 733             {
 734                 SetValue(LineSpacingProperty, value);
 735                 NotifyPropertyChanged();
 736             }
 737         }
 738
 739         /// <summary>
 740         /// The Underline property.<br />
 741         /// The default underline parameters.<br />
 742         /// The underline map contains the following keys :<br />
 743         /// <list type="table">
 744         /// <item><term>enable (bool)</term><description>Whether the underline is enabled (the default value is false)</description></item>
 745         /// <item><term>color (Color)</term><description>The color of the underline (If not provided then the color of the text is used)</description></item>
 746         /// <item><term>height (float)</term><description>The height in pixels of the underline (the default value is 1.f)</description></item>
 747         /// </list>
 748         /// </summary>
 749         /// <since_tizen> 3 </since_tizen>
 750         [System.Diagnostics.CodeAnalysis.SuppressMessage("Naming", "CA1721: Property names should not match get methods")]
 751         public PropertyMap Underline
 752         {
 753             get
 754             {
 755                 return (PropertyMap)GetValue(UnderlineProperty);
 756             }
 757             set
 758             {
 759                 SetValue(UnderlineProperty, value);
 760                 NotifyPropertyChanged();
 761             }
 762         }
 763
 764         /// <summary>
 765         /// Set Underline to TextLabel. <br />
 766         /// </summary>
 767         /// <param name="underline">The Underline</param>
 768         /// <remarks>
 769         /// SetUnderline specifies the underline of the text through <see cref="Tizen.NUI.Text.Underline"/>. <br />
 770         /// </remarks>
 771         /// <example>
 772         /// The following example demonstrates how to use the SetUnderline method.
 773         /// <code>
 774         /// var underline = new Tizen.NUI.Text.Underline();
 775         /// underline.Enable = true;
 776         /// underline.Color = new Color("#3498DB");
 777         /// underline.Height = 2.0f;
 778         /// label.SetUnderline(underline);
 779         /// </code>
 780         /// </example>
 781         [EditorBrowsable(EditorBrowsableState.Never)]
 782         public void SetUnderline(Underline underline)
 783         {
 784             SetValue(UnderlineProperty, TextUtils.GetUnderlineMap(underline));
 785         }
 786
 787         /// <summary>
 788         /// Get Underline from TextLabel. <br />
 789         /// </summary>
 790         /// <returns>The Underline</returns>
 791         /// <remarks>
 792         /// <see cref="Tizen.NUI.Text.Underline"/>
 793         /// </remarks>
 794         [EditorBrowsable(EditorBrowsableState.Never)]
 795         public Underline GetUnderline()
 796         {
 797             return TextUtils.GetUnderlineStruct((PropertyMap)GetValue(UnderlineProperty));
 798         }
 799
 800         /// <summary>
 801         /// The Shadow property.<br />
 802         /// The default shadow parameters.<br />
 803         /// The shadow map contains the following keys :<br />
 804         /// <list type="table">
 805         /// <item><term>color (Color)</term><description>The color of the shadow (the default color is Color.Black)</description></item>
 806         /// <item><term>offset (Vector2)</term><description>The offset in pixels of the shadow (If not provided then the shadow is not enabled)</description></item>
 807         /// <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>
 808         /// </list>
 809         /// </summary>
 810         /// <since_tizen> 3 </since_tizen>
 811         [System.Diagnostics.CodeAnalysis.SuppressMessage("Naming", "CA1721: Property names should not match get methods")]
 812         public PropertyMap Shadow
 813         {
 814             get
 815             {
 816                 return (PropertyMap)GetValue(ShadowProperty);
 817             }
 818             set
 819             {
 820                 SetValue(ShadowProperty, value);
 821                 NotifyPropertyChanged();
 822             }
 823         }
 824
 825         /// <summary>
 826         /// Set Shadow to TextLabel. <br />
 827         /// </summary>
 828         /// <param name="shadow">The Shadow</param>
 829         /// <remarks>
 830         /// SetShadow specifies the shadow of the text through <see cref="Tizen.NUI.Text.Shadow"/>. <br />
 831         /// </remarks>
 832         /// <example>
 833         /// The following example demonstrates how to use the SetShadow method.
 834         /// <code>
 835         /// var shadow = new Tizen.NUI.Text.Shadow();
 836         /// shadow.Offset = new Vector2(3, 3);
 837         /// shadow.Color = new Color("#F1C40F");
 838         /// shadow.BlurRadius = 4.0f;
 839         /// label.SetShadow(shadow);
 840         /// </code>
 841         /// </example>
 842         [EditorBrowsable(EditorBrowsableState.Never)]
 843         public void SetShadow(Tizen.NUI.Text.Shadow shadow)
 844         {
 845             SetValue(ShadowProperty, TextUtils.GetShadowMap(shadow));
 846         }
 847
 848         /// <summary>
 849         /// Get Shadow from TextLabel. <br />
 850         /// </summary>
 851         /// <returns>The Shadow</returns>
 852         /// <remarks>
 853         /// <see cref="Tizen.NUI.Text.Shadow"/>
 854         /// </remarks>
 855         [EditorBrowsable(EditorBrowsableState.Never)]
 856         public Tizen.NUI.Text.Shadow GetShadow()
 857         {
 858             return TextUtils.GetShadowStruct((PropertyMap)GetValue(ShadowProperty));
 859         }
 860
 861         /// <summary>
 862         /// Describes a text shadow for a TextLabel.
 863         /// It is null by default.
 864         /// </summary>
 865         [EditorBrowsable(EditorBrowsableState.Never)]
 866         public TextShadow TextShadow
 867         {
 868             get
 869             {
 870                 return (TextShadow)GetValue(TextShadowProperty);
 871             }
 872             set
 873             {
 874                 SetValue(TextShadowProperty, value);
 875                 NotifyPropertyChanged();
 876             }
 877         }
 878
 879         /// <summary>
 880         /// The Emboss property.<br />
 881         /// The default emboss parameters.<br />
 882         /// </summary>
 883         /// <since_tizen> 3 </since_tizen>
 884         public string Emboss
 885         {
 886             get
 887             {
 888                 return (string)GetValue(EmbossProperty);
 889             }
 890             set
 891             {
 892                 SetValue(EmbossProperty, value);
 893                 NotifyPropertyChanged();
 894             }
 895         }
 896
 897         /// <summary>
 898         /// The Outline property.<br />
 899         /// The default outline parameters.<br />
 900         /// The outline map contains the following keys :<br />
 901         /// <list type="table">
 902         /// <item><term>color (Color)</term><description>The color of the outline (the default color is Color.White)</description></item>
 903         /// <item><term>width (float)</term><description>The width in pixels of the outline (If not provided then the outline is not enabled)</description></item>
 904         /// </list>
 905         /// </summary>
 906         /// <since_tizen> 3 </since_tizen>
 907         [System.Diagnostics.CodeAnalysis.SuppressMessage("Naming", "CA1721: Property names should not match get methods")]
 908         public PropertyMap Outline
 909         {
 910             get
 911             {
 912                 return (PropertyMap)GetValue(OutlineProperty);
 913             }
 914             set
 915             {
 916                 SetValue(OutlineProperty, value);
 917                 NotifyPropertyChanged();
 918             }
 919         }
 920
 921         /// <summary>
 922         /// Set Outline to TextLabel. <br />
 923         /// </summary>
 924         /// <param name="outline">The Outline</param>
 925         /// <remarks>
 926         /// SetOutline specifies the outline of the text through <see cref="Tizen.NUI.Text.Outline"/>. <br />
 927         /// </remarks>
 928         /// <example>
 929         /// The following example demonstrates how to use the SetOutline method.
 930         /// <code>
 931         /// var outline = new Tizen.NUI.Text.Outline();
 932         /// outline.Width = 2.0f;
 933         /// outline.Color = new Color("#45B39D");
 934         /// label.SetOutline(outline);
 935         /// </code>
 936         /// </example>
 937         [EditorBrowsable(EditorBrowsableState.Never)]
 938         public void SetOutline(Outline outline)
 939         {
 940             SetValue(OutlineProperty, TextUtils.GetOutlineMap(outline));
 941         }
 942
 943         /// <summary>
 944         /// Get Outline from TextLabel. <br />
 945         /// </summary>
 946         /// <returns>The Outline</returns>
 947         /// <remarks>
 948         /// <see cref="Tizen.NUI.Text.Outline"/>
 949         /// </remarks>
 950         [EditorBrowsable(EditorBrowsableState.Never)]
 951         public Outline GetOutline()
 952         {
 953             return TextUtils.GetOutlineStruct((PropertyMap)GetValue(OutlineProperty));
 954         }
 955
 956         /// <summary>
 957         /// The PixelSize property.<br />
 958         /// The size of font in pixels.<br />
 959         /// </summary>
 960         /// <since_tizen> 3 </since_tizen>
 961         public float PixelSize
 962         {
 963             get
 964             {
 965                 return (float)GetValue(PixelSizeProperty);
 966             }
 967             set
 968             {
 969                 SetValue(PixelSizeProperty, value);
 970                 NotifyPropertyChanged();
 971             }
 972         }
 973
 974         /// <summary>
 975         /// The Ellipsis property.<br />
 976         /// Enable or disable the ellipsis.<br />
 977         /// </summary>
 978         /// <since_tizen> 3 </since_tizen>
 979         public bool Ellipsis
 980         {
 981             get
 982             {
 983                 return (bool)GetValue(EllipsisProperty);
 984             }
 985             set
 986             {
 987                 SetValue(EllipsisProperty, value);
 988                 NotifyPropertyChanged();
 989             }
 990         }
 991
 992         /// <summary>
 993         /// The ellipsis position of the text.
 994         /// Specifies which portion of the text should be replaced with an ellipsis when the text size exceeds the layout size.<br />
 995         /// </summary>
 996         /// <since_tizen> 9 </since_tizen>
 997         public EllipsisPosition EllipsisPosition
 998         {
 999             get
1000             {
1001                 return (EllipsisPosition)GetValue(EllipsisPositionProperty);
1002             }
1003             set
1004             {
1005                 SetValue(EllipsisPositionProperty, value);
1006                 NotifyPropertyChanged();
1007             }
1008         }
1009
1010         /// <summary>
1011         /// The AutoScrollLoopDelay property.<br />
1012         /// Do something.<br />
1013         /// </summary>
1014         /// <since_tizen> 3 </since_tizen>
1015         public float AutoScrollLoopDelay
1016         {
1017             get
1018             {
1019                 return (float)GetValue(AutoScrollLoopDelayProperty);
1020             }
1021             set
1022             {
1023                 SetValue(AutoScrollLoopDelayProperty, value);
1024                 NotifyPropertyChanged();
1025             }
1026         }
1027
1028         /// <summary>
1029         /// The AutoScrollStopMode property.<br />
1030         /// Do something.<br />
1031         /// </summary>
1032         /// <since_tizen> 3 </since_tizen>
1033         public AutoScrollStopMode AutoScrollStopMode
1034         {
1035             get
1036             {
1037                 return (AutoScrollStopMode)GetValue(AutoScrollStopModeProperty);
1038             }
1039             set
1040             {
1041                 SetValue(AutoScrollStopModeProperty, value);
1042                 NotifyPropertyChanged();
1043             }
1044         }
1045
1046         /// <summary>
1047         /// The line count of the text.
1048         /// </summary>
1049         /// <since_tizen> 3 </since_tizen>
1050         public int LineCount
1051         {
1052             get
1053             {
1054                 int temp = 0;
1055                 GetProperty(TextLabel.Property.LineCount).Get(out temp);
1056                 return temp;
1057             }
1058         }
1059
1060         /// <summary>
1061         /// The LineWrapMode property.<br />
1062         /// line wrap mode when the text lines over layout width.<br />
1063         /// </summary>
1064         /// <since_tizen> 4 </since_tizen>
1065         public LineWrapMode LineWrapMode
1066         {
1067             get
1068             {
1069                 return (LineWrapMode)GetValue(LineWrapModeProperty);
1070             }
1071             set
1072             {
1073                 SetValue(LineWrapModeProperty, value);
1074                 NotifyPropertyChanged();
1075             }
1076         }
1077
1078         /// <summary>
1079         /// The direction of the text such as left to right or right to left.
1080         /// </summary>
1081         /// <since_tizen> 5 </since_tizen>
1082         /// This will be released at Tizen.NET API Level 5, so currently this would be used as inhouse API.
1083         [EditorBrowsable(EditorBrowsableState.Never)]
1084         public TextDirection TextDirection
1085         {
1086             get
1087             {
1088                 int temp = 0;
1089                 GetProperty(TextLabel.Property.TextDirection).Get(out temp);
1090                 return (TextDirection)temp;
1091             }
1092         }
1093
1094         /// <summary>
1095         /// The vertical line alignment of the text.
1096         /// </summary>
1097         /// <since_tizen> 5 </since_tizen>
1098         /// This will be released at Tizen.NET API Level 5, so currently this would be used as inhouse API.
1099         [EditorBrowsable(EditorBrowsableState.Never)]
1100         public VerticalLineAlignment VerticalLineAlignment
1101         {
1102             get
1103             {
1104                 return (VerticalLineAlignment)GetValue(VerticalLineAlignmentProperty);
1105             }
1106             set
1107             {
1108                 SetValue(VerticalLineAlignmentProperty, value);
1109                 NotifyPropertyChanged();
1110             }
1111         }
1112
1113         /// <summary>
1114         /// The text alignment to match the direction of the system language.
1115         /// </summary>
1116         /// <since_tizen> 6 </since_tizen>
1117         public bool MatchSystemLanguageDirection
1118         {
1119             get
1120             {
1121                 return (bool)GetValue(MatchSystemLanguageDirectionProperty);
1122             }
1123             set
1124             {
1125                 SetValue(MatchSystemLanguageDirectionProperty, value);
1126                 NotifyPropertyChanged();
1127             }
1128         }
1129
1130         /// <summary>
1131         /// The text fit parameters.<br />
1132         /// The textFit map contains the following keys :<br />
1133         /// <list type="table">
1134         /// <item><term>enable (bool)</term><description>True to enable the text fit or false to disable (the default value is false)</description></item>
1135         /// <item><term>minSize (float)</term><description>Minimum Size for text fit (the default value is 10.f)</description></item>
1136         /// <item><term>maxSize (float)</term><description>Maximum Size for text fit (the default value is 100.f)</description></item>
1137         /// <item><term>stepSize (float)</term><description>Step Size for font increase (the default value is 1.f)</description></item>
1138         /// <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>
1139         /// </list>
1140         /// </summary>
1141         /// This will be public opened in tizen_5.5 after ACR done. Before ACR, need to be hidden as inhouse API.
1142         [EditorBrowsable(EditorBrowsableState.Never)]
1143         [System.Diagnostics.CodeAnalysis.SuppressMessage("Naming", "CA1721: Property names should not match get methods")]
1144         public PropertyMap TextFit
1145         {
1146             get
1147             {
1148                 return (PropertyMap)GetValue(TextFitProperty);
1149             }
1150             set
1151             {
1152                 SetValue(TextFitProperty, value);
1153                 NotifyPropertyChanged();
1154             }
1155         }
1156
1157         /// <summary>
1158         /// Set TextFit to TextLabel. <br />
1159         /// </summary>
1160         /// <param name="textFit">The TextFit</param>
1161         /// <remarks>
1162         /// SetTextFit specifies the textFit of the text through <see cref="Tizen.NUI.Text.TextFit"/>. <br />
1163         /// </remarks>
1164         /// <example>
1165         /// The following example demonstrates how to use the SetTextFit method.
1166         /// <code>
1167         /// var textFit = new Tizen.NUI.Text.TextFit();
1168         /// textFit.Enable = true;
1169         /// textFit.MinSize = 10.0f;
1170         /// textFit.MaxSize = 100.0f;
1171         /// textFit.StepSize = 5.0f;
1172         /// textFit.FontSizeType = FontSizeType.PointSize;
1173         /// label.SetTextFit(textFit);
1174         /// </code>
1175         /// </example>
1176         [EditorBrowsable(EditorBrowsableState.Never)]
1177         public void SetTextFit(TextFit textFit)
1178         {
1179             SetValue(TextFitProperty, TextUtils.GetTextFitMap(textFit));
1180         }
1181
1182         /// <summary>
1183         /// Get TextFit from TextLabel. <br />
1184         /// </summary>
1185         /// <returns>The TextFit</returns>
1186         /// <remarks>
1187         /// TextFit is always returned based on PointSize. <br />
1188         /// If the user sets FontSizeType to PixelSize, then MinSize, MaxSize, and StepSize are converted based on PointSize and returned. <br />
1189         /// <see cref="Tizen.NUI.Text.TextFit"/>
1190         /// </remarks>
1191         [EditorBrowsable(EditorBrowsableState.Never)]
1192         public TextFit GetTextFit()
1193         {
1194             return TextUtils.GetTextFitStruct((PropertyMap)GetValue(TextFitProperty));
1195         }
1196
1197         /// <summary>
1198         /// The MinLineSize property.<br />
1199         /// </summary>
1200         /// <since_tizen> 8 </since_tizen>
1201         [EditorBrowsable(EditorBrowsableState.Never)]
1202         public float MinLineSize
1203         {
1204             get
1205             {
1206                 return (float)GetValue(MinLineSizeProperty);
1207             }
1208             set
1209             {
1210                 SetValue(MinLineSizeProperty, value);
1211                 NotifyPropertyChanged();
1212             }
1213         }
1214
1215         /// <summary>
1216         /// The FontSizeScale property. <br />
1217         /// The default value is 1.0. <br />
1218         /// If FontSizeScale.UseSystemSetting, will use the SystemSettings.FontSize internally. <br />
1219         /// </summary>
1220         /// <since_tizen> 9 </since_tizen>
1221         public float FontSizeScale
1222         {
1223             get
1224             {
1225                 return fontSizeScale;
1226             }
1227             set
1228             {
1229                 float newFontSizeScale;
1230
1231                 if (fontSizeScale == value) return;
1232
1233                 fontSizeScale = value;
1234                 if (fontSizeScale == Tizen.NUI.FontSizeScale.UseSystemSetting)
1235                 {
1236                     SystemSettingsFontSize systemSettingsFontSize;
1237
1238                     try
1239                     {
1240                         systemSettingsFontSize = SystemSettings.FontSize;
1241                     }
1242                     catch (Exception e)
1243                     {
1244                         Console.WriteLine("{0} Exception caught.", e);
1245                         systemSettingsFontSize = SystemSettingsFontSize.Normal;
1246                     }
1247                     newFontSizeScale = TextUtils.GetFontSizeScale(systemSettingsFontSize);
1248                     addFontSizeChangedCallback();
1249                 }
1250                 else
1251                 {
1252                     newFontSizeScale = fontSizeScale;
1253                     removeFontSizeChangedCallback();
1254                 }
1255
1256                 SetValue(FontSizeScaleProperty, newFontSizeScale);
1257                 NotifyPropertyChanged();
1258             }
1259         }
1260
1261         private TextLabelSelectorData EnsureSelectorData() => selectorData ?? (selectorData = new TextLabelSelectorData());
1262
1263         /// <summary>
1264         /// Downcasts a handle to textLabel handle
1265         /// </summary>
1266         /// <param name="handle"></param>
1267         /// <returns></returns>
1268         /// <exception cref="ArgumentNullException"> Thrown when handle is null. </exception>
1269         /// <since_tizen> 3 </since_tizen>
1270         /// Please do not use! this will be deprecated!
1271         /// Instead please use as keyword.
1272         [Obsolete("Please do not use! This will be deprecated! Please use as keyword instead! " +
1273             "Like: " +
1274             "BaseHandle handle = new TextLabel(\"Hello World!\"); " +
1275             "TextLabel label = handle as TextLabel")]
1276         [EditorBrowsable(EditorBrowsableState.Never)]
1277         public static TextLabel DownCast(BaseHandle handle)
1278         {
1279             if (null == handle)
1280             {
1281                 throw new ArgumentNullException(nameof(handle));
1282             }
1283             TextLabel ret = Registry.GetManagedBaseHandleFromNativePtr(handle) as TextLabel;
1284             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1285             return ret;
1286         }
1287
1288         /// <inheritdoc/>
1289         [EditorBrowsable(EditorBrowsableState.Never)]
1290         protected override void Dispose(DisposeTypes type)
1291         {
1292             if (disposed)
1293             {
1294                 return;
1295             }
1296
1297             if (systemlangTextFlag)
1298             {
1299                 SystemSettings.LocaleLanguageChanged -= SystemSettings_LocaleLanguageChanged;
1300             }
1301
1302             removeFontSizeChangedCallback();
1303
1304             if (type == DisposeTypes.Explicit)
1305             {
1306                 //Called by User
1307                 //Release your own managed resources here.
1308                 //You should release all of your own disposable objects here.
1309                 selectorData?.Reset(this);
1310             }
1311
1312             base.Dispose(type);
1313         }
1314
1315         /// This will not be public opened.
1316         [EditorBrowsable(EditorBrowsableState.Never)]
1317         protected override void ReleaseSwigCPtr(System.Runtime.InteropServices.HandleRef swigCPtr)
1318         {
1319             Interop.TextLabel.DeleteTextLabel(swigCPtr);
1320         }
1321
1322         /// <summary>
1323         /// Get attribues, it is abstract function and must be override.
1324         /// </summary>
1325         [EditorBrowsable(EditorBrowsableState.Never)]
1326         protected override ViewStyle CreateViewStyle()
1327         {
1328             return new TextLabelStyle();
1329         }
1330
1331         /// <summary>
1332         /// Invoked whenever the binding context of the textlabel changes. Implement this method to add class handling for this event.
1333         /// </summary>
1334         protected override void OnBindingContextChanged()
1335         {
1336             base.OnBindingContextChanged();
1337         }
1338
1339         private void SystemSettings_LocaleLanguageChanged(object sender, LocaleLanguageChangedEventArgs e)
1340         {
1341             Text = NUIApplication.MultilingualResourceManager?.GetString(textLabelSid, new CultureInfo(e.Value.Replace("_", "-")));
1342         }
1343
1344         private void SystemSettingsFontSizeChanged(object sender, FontSizeChangedEventArgs e)
1345         {
1346             float newFontSizeScale = TextUtils.GetFontSizeScale(e.Value);
1347             SetValue(FontSizeScaleProperty, newFontSizeScale);
1348         }
1349
1350         private void addFontSizeChangedCallback()
1351         {
1352             if (hasFontSizeChangedCallback != true)
1353             {
1354                 try
1355                 {
1356                     SystemSettings.FontSizeChanged += SystemSettingsFontSizeChanged;
1357                     hasFontSizeChangedCallback = true;
1358                 }
1359                 catch (Exception e)
1360                 {
1361                     Console.WriteLine("{0} Exception caught.", e);
1362                     hasFontSizeChangedCallback = false;
1363                 }
1364             }
1365         }
1366
1367         private void removeFontSizeChangedCallback()
1368         {
1369             if (hasFontSizeChangedCallback == true)
1370             {
1371                 try
1372                 {
1373                     SystemSettings.FontSizeChanged -= SystemSettingsFontSizeChanged;
1374                     hasFontSizeChangedCallback = false;
1375                 }
1376                 catch (Exception e)
1377                 {
1378                     Console.WriteLine("{0} Exception caught.", e);
1379                     hasFontSizeChangedCallback = true;
1380                 }
1381             }
1382         }
1383
1384         private void RequestLayout()
1385         {
1386             Layout?.RequestLayout();
1387         }
1388
1389         internal new class Property
1390         {
1391             internal static readonly int TEXT = Interop.TextLabel.TextGet();
1392             internal static readonly int FontFamily = Interop.TextLabel.FontFamilyGet();
1393             internal static readonly int FontStyle = Interop.TextLabel.FontStyleGet();
1394             internal static readonly int PointSize = Interop.TextLabel.PointSizeGet();
1395             internal static readonly int MultiLine = Interop.TextLabel.MultiLineGet();
1396             internal static readonly int HorizontalAlignment = Interop.TextLabel.HorizontalAlignmentGet();
1397             internal static readonly int VerticalAlignment = Interop.TextLabel.VerticalAlignmentGet();
1398             internal static readonly int TextColor = Interop.TextLabel.TextColorGet();
1399             internal static readonly int EnableMarkup = Interop.TextLabel.EnableMarkupGet();
1400             internal static readonly int EnableAutoScroll = Interop.TextLabel.EnableAutoScrollGet();
1401             internal static readonly int AutoScrollSpeed = Interop.TextLabel.AutoScrollSpeedGet();
1402             internal static readonly int AutoScrollLoopCount = Interop.TextLabel.AutoScrollLoopCountGet();
1403             internal static readonly int AutoScrollGap = Interop.TextLabel.AutoScrollGapGet();
1404             internal static readonly int LineSpacing = Interop.TextLabel.LineSpacingGet();
1405             internal static readonly int UNDERLINE = Interop.TextLabel.UnderlineGet();
1406             internal static readonly int SHADOW = Interop.TextLabel.ShadowGet();
1407             internal static readonly int EMBOSS = Interop.TextLabel.EmbossGet();
1408             internal static readonly int OUTLINE = Interop.TextLabel.OutlineGet();
1409             internal static readonly int PixelSize = Interop.TextLabel.PixelSizeGet();
1410             internal static readonly int ELLIPSIS = Interop.TextLabel.EllipsisGet();
1411             internal static readonly int AutoScrollStopMode = Interop.TextLabel.AutoScrollStopModeGet();
1412             internal static readonly int AutoScrollLoopDelay = Interop.TextLabel.AutoScrollLoopDelayGet();
1413             internal static readonly int LineCount = Interop.TextLabel.LineCountGet();
1414             internal static readonly int LineWrapMode = Interop.TextLabel.LineWrapModeGet();
1415             internal static readonly int TextDirection = Interop.TextLabel.TextDirectionGet();
1416             internal static readonly int VerticalLineAlignment = Interop.TextLabel.VerticalLineAlignmentGet();
1417             internal static readonly int MatchSystemLanguageDirection = Interop.TextLabel.MatchSystemLanguageDirectionGet();
1418             internal static readonly int TextFit = Interop.TextLabel.TextFitGet();
1419             internal static readonly int MinLineSize = Interop.TextLabel.MinLineSizeGet();
1420             internal static readonly int FontSizeScale = Interop.TextLabel.FontSizeScaleGet();
1421             internal static readonly int EllipsisPosition = Interop.TextLabel.EllipsisPositionGet();
1422         }
1423
1424         private void OnShadowColorChanged(float x, float y, float z, float w)
1425         {
1426             ShadowColor = new Vector4(x, y, z, w);
1427         }
1428         private void OnShadowOffsetChanged(float x, float y)
1429         {
1430             ShadowOffset = new Vector2(x, y);
1431         }
1432         private void OnTextColorChanged(float r, float g, float b, float a)
1433         {
1434             TextColor = new Color(r, g, b, a);
1435         }
1436         private void OnUnderlineColorChanged(float x, float y, float z, float w)
1437         {
1438             UnderlineColor = new Vector4(x, y, z, w);
1439         }
1440     }
1441 }