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         public PropertyMap FontStyle
 272         {
 273             get
 274             {
 275                 return (PropertyMap)GetValue(FontStyleProperty);
 276             }
 277             set
 278             {
 279                 SetValue(FontStyleProperty, value);
 280                 NotifyPropertyChanged();
 281             }
 282         }
 283
 284         /// <summary>
 285         /// Set FontStyle to TextLabel. <br />
 286         /// </summary>
 287         /// <param name="fontStyle">The FontStyle</param>
 288         /// <remarks>
 289         /// SetFontStyle specifies the requested font style through <see cref="Tizen.NUI.Text.FontStyle"/>. <br />
 290         /// </remarks>
 291         /// <example>
 292         /// The following example demonstrates how to use the SetFontStyle method.
 293         /// <code>
 294         /// var fontStyle = new Tizen.NUI.Text.FontStyle();
 295         /// fontStyle.Width = FontWidthType.Expanded;
 296         /// fontStyle.Weight = FontWeightType.Bold;
 297         /// fontStyle.Slant = FontSlantType.Italic;
 298         /// label.SetFontStyle(fontStyle);
 299         /// </code>
 300         /// </example>
 301         [EditorBrowsable(EditorBrowsableState.Never)]
 302         public void SetFontStyle(FontStyle fontStyle)
 303         {
 304             SetProperty(TextLabel.Property.FontStyle, new PropertyValue(TextUtils.GetFontStyleMap(fontStyle)));
 305         }
 306
 307         /// <summary>
 308         /// Get FontStyle from TextLabel. <br />
 309         /// </summary>
 310         /// <returns>The FontStyle</returns>
 311         /// <remarks>
 312         /// <see cref="Tizen.NUI.Text.FontStyle"/>
 313         /// </remarks>
 314         [EditorBrowsable(EditorBrowsableState.Never)]
 315         public FontStyle GetFontStyle()
 316         {
 317             var map = new PropertyMap();
 318             GetProperty(TextLabel.Property.FontStyle).Get(map);
 319             return TextUtils.GetFontStyleStruct(map);
 320         }
 321
 322         /// <summary>
 323         /// The PointSize property.<br />
 324         /// The size of font in points.<br />
 325         /// </summary>
 326         /// <since_tizen> 3 </since_tizen>
 327         public float PointSize
 328         {
 329             get
 330             {
 331                 return (float)GetValue(PointSizeProperty);
 332             }
 333             set
 334             {
 335                 SetValue(PointSizeProperty, value);
 336                 NotifyPropertyChanged();
 337             }
 338         }
 339
 340         /// <summary>
 341         /// The MultiLine property.<br />
 342         /// The single-line or multi-line layout option.<br />
 343         /// </summary>
 344         /// <since_tizen> 3 </since_tizen>
 345         public bool MultiLine
 346         {
 347             get
 348             {
 349                 return (bool)GetValue(MultiLineProperty);
 350             }
 351             set
 352             {
 353                 SetValue(MultiLineProperty, value);
 354                 NotifyPropertyChanged();
 355             }
 356         }
 357
 358         /// <summary>
 359         /// The HorizontalAlignment property.<br />
 360         /// The line horizontal alignment.<br />
 361         /// </summary>
 362         /// <since_tizen> 3 </since_tizen>
 363         public HorizontalAlignment HorizontalAlignment
 364         {
 365             get
 366             {
 367                 return (HorizontalAlignment)GetValue(HorizontalAlignmentProperty);
 368             }
 369             set
 370             {
 371                 SetValue(HorizontalAlignmentProperty, value);
 372                 NotifyPropertyChanged();
 373             }
 374         }
 375
 376         /// <summary>
 377         /// The VerticalAlignment property.<br />
 378         /// The line vertical alignment.<br />
 379         /// </summary>
 380         /// <since_tizen> 3 </since_tizen>
 381         public VerticalAlignment VerticalAlignment
 382         {
 383             get
 384             {
 385                 return (VerticalAlignment)GetValue(VerticalAlignmentProperty);
 386             }
 387             set
 388             {
 389                 SetValue(VerticalAlignmentProperty, value);
 390                 NotifyPropertyChanged();
 391             }
 392         }
 393
 394         /// <summary>
 395         /// The TextColor property.<br />
 396         /// The color of the text.<br />
 397         /// Animation framework can be used to change the color of the text when not using mark up.<br />
 398         /// Cannot animate the color when text is auto scrolling.<br />
 399         /// </summary>
 400         /// <remarks>
 401         /// The property cascade chaining set is possible. For example, this (textLabel.TextColor.X = 0.1f;) is possible.
 402         /// </remarks>
 403         /// <since_tizen> 3 </since_tizen>
 404         public Color TextColor
 405         {
 406             get
 407             {
 408                 Color temp = (Color)GetValue(TextColorProperty);
 409                 return new Color(OnTextColorChanged, temp.R, temp.G, temp.B, temp.A);
 410             }
 411             set
 412             {
 413                 SetValue(TextColorProperty, value);
 414                 NotifyPropertyChanged();
 415             }
 416         }
 417
 418         /// <summary>
 419         /// The ShadowOffset property.<br />
 420         /// The drop shadow offset 0 indicates no shadow.<br />
 421         /// </summary>
 422         /// <since_tizen> 3 </since_tizen>
 423         /// <remarks>
 424         /// Deprecated.(API Level 6) Use Shadow instead.
 425         /// The property cascade chaining set is possible. For example, this (textLabel.ShadowOffset.X = 0.1f;) is possible.
 426         /// </remarks>
 427         [Obsolete("Please do not use this ShadowOffset(Deprecated). Please use Shadow instead.")]
 428         public Vector2 ShadowOffset
 429         {
 430             get
 431             {
 432                 Vector2 shadowOffset = new Vector2();
 433                 Shadow.Find(TextLabel.Property.SHADOW, "offset")?.Get(shadowOffset);
 434                 return new Vector2(OnShadowOffsetChanged, shadowOffset.X, shadowOffset.Y);
 435             }
 436             set
 437             {
 438                 PropertyMap temp = new PropertyMap();
 439                 temp.Insert("offset", new PropertyValue(value));
 440
 441                 PropertyMap shadowMap = Shadow;
 442                 shadowMap.Merge(temp);
 443
 444                 SetValue(ShadowProperty, shadowMap);
 445                 NotifyPropertyChanged();
 446             }
 447         }
 448
 449         /// <summary>
 450         /// The ShadowColor property.<br />
 451         /// The color of a drop shadow.<br />
 452         /// </summary>
 453         /// <since_tizen> 3 </since_tizen>
 454         /// <remarks>
 455         /// Deprecated.(API Level 6) Use Shadow instead.
 456         /// The property cascade chaining set is possible. For example, this (textLabel.ShadowColor.X = 0.1f;) is possible.
 457         /// </remarks>
 458         [Obsolete("Please do not use this ShadowColor(Deprecated). Please use Shadow instead.")]
 459         public Vector4 ShadowColor
 460         {
 461             get
 462             {
 463                 Vector4 shadowColor = new Vector4();
 464                 Shadow.Find(TextLabel.Property.SHADOW, "color")?.Get(shadowColor);
 465                 return new Vector4(OnShadowColorChanged, shadowColor.X, shadowColor.Y, shadowColor.Z, shadowColor.W);
 466             }
 467             set
 468             {
 469                 PropertyMap temp = new PropertyMap();
 470                 temp.Insert("color", new PropertyValue(value));
 471
 472                 PropertyMap shadowMap = Shadow;
 473                 shadowMap.Merge(temp);
 474
 475                 SetValue(ShadowProperty, shadowMap);
 476                 NotifyPropertyChanged();
 477             }
 478         }
 479
 480         /// <summary>
 481         /// The UnderlineEnabled property.<br />
 482         /// The underline enabled flag.<br />
 483         /// </summary>
 484         /// <since_tizen> 3 </since_tizen>
 485         /// <remarks>
 486         /// Deprecated.(API Level 6) Use Underline instead.
 487         /// </remarks>
 488         [Obsolete("Please do not use this UnderlineEnabled(Deprecated). Please use Underline instead.")]
 489         public bool UnderlineEnabled
 490         {
 491             get
 492             {
 493                 bool underlineEnabled = false;
 494                 Underline.Find(TextLabel.Property.UNDERLINE, "enable")?.Get(out underlineEnabled);
 495                 return underlineEnabled;
 496             }
 497             set
 498             {
 499                 PropertyMap temp = new PropertyMap();
 500                 temp.Add("enable", new PropertyValue(value));
 501
 502                 PropertyMap undelineMap = Underline;
 503                 undelineMap.Merge(temp);
 504
 505                 SetValue(UnderlineProperty, undelineMap);
 506                 NotifyPropertyChanged();
 507
 508             }
 509         }
 510
 511         /// <summary>
 512         /// The UnderlineColor property.<br />
 513         /// Overrides the underline height from font metrics.<br />
 514         /// </summary>
 515         /// <since_tizen> 3 </since_tizen>
 516         /// <remarks>
 517         /// Deprecated.(API Level 6) Use Underline instead.
 518         /// The property cascade chaining set is possible. For example, this (textLabel.UnderlineColor.X = 0.1f;) is possible.
 519         /// </remarks>
 520         [Obsolete("Please do not use this UnderlineColor(Deprecated). Please use Underline instead.")]
 521         public Vector4 UnderlineColor
 522         {
 523             get
 524             {
 525                 Vector4 underlineColor = new Vector4();
 526                 Underline.Find(TextLabel.Property.UNDERLINE, "color")?.Get(underlineColor);
 527                 return new Vector4(OnUnderlineColorChanged, underlineColor.X, underlineColor.Y, underlineColor.Z, underlineColor.W);
 528             }
 529             set
 530             {
 531                 PropertyMap temp = new PropertyMap();
 532                 temp.Insert("color", new PropertyValue(value));
 533
 534                 PropertyMap undelineMap = Underline;
 535                 undelineMap.Merge(temp);
 536
 537                 SetValue(UnderlineProperty, undelineMap);
 538                 NotifyPropertyChanged();
 539             }
 540         }
 541
 542         /// <summary>
 543         /// The UnderlineHeight property.<br />
 544         /// Overrides the underline height from font metrics.<br />
 545         /// </summary>
 546         /// <since_tizen> 3 </since_tizen>
 547         /// <remarks>
 548         /// Deprecated.(API Level 6) Use Underline instead.
 549         /// </remarks>
 550         [Obsolete("Please do not use this UnderlineHeight(Deprecated). Please use Underline instead.")]
 551         public float UnderlineHeight
 552         {
 553             get
 554             {
 555                 float underlineHeight = 0.0f;
 556                 Underline.Find(TextLabel.Property.UNDERLINE, "height")?.Get(out underlineHeight);
 557                 return underlineHeight;
 558             }
 559             set
 560             {
 561                 PropertyMap temp = new PropertyMap();
 562                 temp.Insert("height", new PropertyValue(value));
 563
 564                 PropertyMap undelineMap = Underline;
 565                 undelineMap.Merge(temp);
 566
 567                 SetValue(UnderlineProperty, undelineMap);
 568                 NotifyPropertyChanged();
 569             }
 570         }
 571
 572         /// <summary>
 573         /// The EnableMarkup property.<br />
 574         /// Whether the mark-up processing is enabled.<br />
 575         /// </summary>
 576         /// <since_tizen> 3 </since_tizen>
 577         public bool EnableMarkup
 578         {
 579             get
 580             {
 581                 return (bool)GetValue(EnableMarkupProperty);
 582             }
 583             set
 584             {
 585                 SetValue(EnableMarkupProperty, value);
 586                 NotifyPropertyChanged();
 587             }
 588         }
 589
 590         /// <summary>
 591         /// The EnableAutoScroll property.<br />
 592         /// Starts or stops auto scrolling.<br />
 593         /// </summary>
 594         /// <since_tizen> 3 </since_tizen>
 595         public bool EnableAutoScroll
 596         {
 597             get
 598             {
 599                 return (bool)GetValue(EnableAutoScrollProperty);
 600             }
 601             set
 602             {
 603                 SetValue(EnableAutoScrollProperty, value);
 604                 NotifyPropertyChanged();
 605             }
 606         }
 607
 608         /// <summary>
 609         /// The AutoScrollSpeed property.<br />
 610         /// Sets the speed of scrolling in pixels per second.<br />
 611         /// </summary>
 612         /// <since_tizen> 3 </since_tizen>
 613         public int AutoScrollSpeed
 614         {
 615             get
 616             {
 617                 return (int)GetValue(AutoScrollSpeedProperty);
 618             }
 619             set
 620             {
 621                 SetValue(AutoScrollSpeedProperty, value);
 622                 NotifyPropertyChanged();
 623             }
 624         }
 625
 626         /// <summary>
 627         /// The AutoScrollLoopCount property.<br />
 628         /// Number of complete loops when scrolling enabled.<br />
 629         /// </summary>
 630         /// <since_tizen> 3 </since_tizen>
 631         public int AutoScrollLoopCount
 632         {
 633             get
 634             {
 635                 return (int)GetValue(AutoScrollLoopCountProperty);
 636             }
 637             set
 638             {
 639                 SetValue(AutoScrollLoopCountProperty, value);
 640                 NotifyPropertyChanged();
 641             }
 642         }
 643
 644         /// <summary>
 645         /// The AutoScrollGap property.<br />
 646         /// Gap before scrolling wraps.<br />
 647         /// </summary>
 648         /// <since_tizen> 3 </since_tizen>
 649         public float AutoScrollGap
 650         {
 651             get
 652             {
 653                 return (float)GetValue(AutoScrollGapProperty);
 654             }
 655             set
 656             {
 657                 SetValue(AutoScrollGapProperty, value);
 658                 NotifyPropertyChanged();
 659             }
 660         }
 661
 662         /// <summary>
 663         /// The LineSpacing property.<br />
 664         /// The default extra space between lines in points.<br />
 665         /// </summary>
 666         /// <since_tizen> 3 </since_tizen>
 667         public float LineSpacing
 668         {
 669             get
 670             {
 671                 return (float)GetValue(LineSpacingProperty);
 672             }
 673             set
 674             {
 675                 SetValue(LineSpacingProperty, value);
 676                 NotifyPropertyChanged();
 677             }
 678         }
 679
 680         /// <summary>
 681         /// The Underline property.<br />
 682         /// The default underline parameters.<br />
 683         /// The underline map contains the following keys :<br />
 684         /// <list type="table">
 685         /// <item><term>enable (bool)</term><description>Whether the underline is enabled (the default value is false)</description></item>
 686         /// <item><term>color (Color)</term><description>The color of the underline (If not provided then the color of the text is used)</description></item>
 687         /// <item><term>height (float)</term><description>The height in pixels of the underline (the default value is 1.f)</description></item>
 688         /// </list>
 689         /// </summary>
 690         /// <since_tizen> 3 </since_tizen>
 691         public PropertyMap Underline
 692         {
 693             get
 694             {
 695                 return (PropertyMap)GetValue(UnderlineProperty);
 696             }
 697             set
 698             {
 699                 SetValue(UnderlineProperty, value);
 700                 NotifyPropertyChanged();
 701             }
 702         }
 703
 704         /// <summary>
 705         /// Set Underline to TextLabel. <br />
 706         /// </summary>
 707         /// <param name="underline">The Underline</param>
 708         /// <remarks>
 709         /// SetUnderline specifies the underline of the text through <see cref="Tizen.NUI.Text.Underline"/>. <br />
 710         /// </remarks>
 711         /// <example>
 712         /// The following example demonstrates how to use the SetUnderline method.
 713         /// <code>
 714         /// var underline = new Tizen.NUI.Text.Underline();
 715         /// underline.Enable = true;
 716         /// underline.Color = new Color("#3498DB");
 717         /// underline.Height = 2.0f;
 718         /// label.SetUnderline(underline);
 719         /// </code>
 720         /// </example>
 721         [EditorBrowsable(EditorBrowsableState.Never)]
 722         public void SetUnderline(Underline underline)
 723         {
 724             SetProperty(TextLabel.Property.UNDERLINE, new PropertyValue(TextUtils.GetUnderlineMap(underline)));
 725         }
 726
 727         /// <summary>
 728         /// Get Underline from TextLabel. <br />
 729         /// </summary>
 730         /// <returns>The Underline</returns>
 731         /// <remarks>
 732         /// <see cref="Tizen.NUI.Text.Underline"/>
 733         /// </remarks>
 734         [EditorBrowsable(EditorBrowsableState.Never)]
 735         public Underline GetUnderline()
 736         {
 737             var map = new PropertyMap();
 738             GetProperty(TextLabel.Property.UNDERLINE).Get(map);
 739             return TextUtils.GetUnderlineStruct(map);
 740         }
 741
 742         /// <summary>
 743         /// The Shadow property.<br />
 744         /// The default shadow parameters.<br />
 745         /// The shadow map contains the following keys :<br />
 746         /// <list type="table">
 747         /// <item><term>color (Color)</term><description>The color of the shadow (the default color is Color.Black)</description></item>
 748         /// <item><term>offset (Vector2)</term><description>The offset in pixels of the shadow (If not provided then the shadow is not enabled)</description></item>
 749         /// <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>
 750         /// </list>
 751         /// </summary>
 752         /// <since_tizen> 3 </since_tizen>
 753         public PropertyMap Shadow
 754         {
 755             get
 756             {
 757                 return (PropertyMap)GetValue(ShadowProperty);
 758             }
 759             set
 760             {
 761                 SetValue(ShadowProperty, value);
 762                 NotifyPropertyChanged();
 763             }
 764         }
 765
 766         /// <summary>
 767         /// Describes a text shadow for a TextLabel.
 768         /// It is null by default.
 769         /// </summary>
 770         [EditorBrowsable(EditorBrowsableState.Never)]
 771         public TextShadow TextShadow
 772         {
 773             get
 774             {
 775                 return (TextShadow)GetValue(TextShadowProperty);
 776             }
 777             set
 778             {
 779                 SetValue(TextShadowProperty, value);
 780                 NotifyPropertyChanged();
 781             }
 782         }
 783
 784         /// <summary>
 785         /// The Emboss property.<br />
 786         /// The default emboss parameters.<br />
 787         /// </summary>
 788         /// <since_tizen> 3 </since_tizen>
 789         public string Emboss
 790         {
 791             get
 792             {
 793                 return (string)GetValue(EmbossProperty);
 794             }
 795             set
 796             {
 797                 SetValue(EmbossProperty, value);
 798                 NotifyPropertyChanged();
 799             }
 800         }
 801
 802         /// <summary>
 803         /// The Outline property.<br />
 804         /// The default outline parameters.<br />
 805         /// The outline map contains the following keys :<br />
 806         /// <list type="table">
 807         /// <item><term>color (Color)</term><description>The color of the outline (the default color is Color.White)</description></item>
 808         /// <item><term>width (float)</term><description>The width in pixels of the outline (If not provided then the outline is not enabled)</description></item>
 809         /// </list>
 810         /// </summary>
 811         /// <since_tizen> 3 </since_tizen>
 812         public PropertyMap Outline
 813         {
 814             get
 815             {
 816                 return (PropertyMap)GetValue(OutlineProperty);
 817             }
 818             set
 819             {
 820                 SetValue(OutlineProperty, value);
 821                 NotifyPropertyChanged();
 822             }
 823         }
 824
 825         /// <summary>
 826         /// The PixelSize property.<br />
 827         /// The size of font in pixels.<br />
 828         /// </summary>
 829         /// <since_tizen> 3 </since_tizen>
 830         public float PixelSize
 831         {
 832             get
 833             {
 834                 return (float)GetValue(PixelSizeProperty);
 835             }
 836             set
 837             {
 838                 SetValue(PixelSizeProperty, value);
 839                 NotifyPropertyChanged();
 840             }
 841         }
 842
 843         /// <summary>
 844         /// The Ellipsis property.<br />
 845         /// Enable or disable the ellipsis.<br />
 846         /// </summary>
 847         /// <since_tizen> 3 </since_tizen>
 848         public bool Ellipsis
 849         {
 850             get
 851             {
 852                 return (bool)GetValue(EllipsisProperty);
 853             }
 854             set
 855             {
 856                 SetValue(EllipsisProperty, value);
 857                 NotifyPropertyChanged();
 858             }
 859         }
 860
 861         /// <summary>
 862         /// The ellipsis position of the text.
 863         /// The ellipsis position type when the text size over the layout size.<br />
 864         /// The ellipsis position: End, Start or Middle.<br />
 865         /// </summary>
 866         [EditorBrowsable(EditorBrowsableState.Never)]
 867         public EllipsisPosition EllipsisPosition
 868         {
 869             get
 870             {
 871                 return (EllipsisPosition)GetValue(EllipsisPositionProperty);
 872             }
 873             set
 874             {
 875                 SetValue(EllipsisPositionProperty, value);
 876                 NotifyPropertyChanged();
 877             }
 878         }
 879
 880         /// <summary>
 881         /// The AutoScrollLoopDelay property.<br />
 882         /// Do something.<br />
 883         /// </summary>
 884         /// <since_tizen> 3 </since_tizen>
 885         public float AutoScrollLoopDelay
 886         {
 887             get
 888             {
 889                 return (float)GetValue(AutoScrollLoopDelayProperty);
 890             }
 891             set
 892             {
 893                 SetValue(AutoScrollLoopDelayProperty, value);
 894                 NotifyPropertyChanged();
 895             }
 896         }
 897
 898         /// <summary>
 899         /// The AutoScrollStopMode property.<br />
 900         /// Do something.<br />
 901         /// </summary>
 902         /// <since_tizen> 3 </since_tizen>
 903         public AutoScrollStopMode AutoScrollStopMode
 904         {
 905             get
 906             {
 907                 return (AutoScrollStopMode)GetValue(AutoScrollStopModeProperty);
 908             }
 909             set
 910             {
 911                 SetValue(AutoScrollStopModeProperty, value);
 912                 NotifyPropertyChanged();
 913             }
 914         }
 915
 916         /// <summary>
 917         /// The line count of the text.
 918         /// </summary>
 919         /// <since_tizen> 3 </since_tizen>
 920         public int LineCount
 921         {
 922             get
 923             {
 924                 int temp = 0;
 925                 GetProperty(TextLabel.Property.LineCount).Get(out temp);
 926                 return temp;
 927             }
 928         }
 929
 930         /// <summary>
 931         /// The LineWrapMode property.<br />
 932         /// line wrap mode when the text lines over layout width.<br />
 933         /// </summary>
 934         /// <since_tizen> 4 </since_tizen>
 935         public LineWrapMode LineWrapMode
 936         {
 937             get
 938             {
 939                 return (LineWrapMode)GetValue(LineWrapModeProperty);
 940             }
 941             set
 942             {
 943                 SetValue(LineWrapModeProperty, value);
 944                 NotifyPropertyChanged();
 945             }
 946         }
 947
 948         /// <summary>
 949         /// The direction of the text such as left to right or right to left.
 950         /// </summary>
 951         /// <since_tizen> 5 </since_tizen>
 952         /// This will be released at Tizen.NET API Level 5, so currently this would be used as inhouse API.
 953         [EditorBrowsable(EditorBrowsableState.Never)]
 954         public TextDirection TextDirection
 955         {
 956             get
 957             {
 958                 int temp = 0;
 959                 GetProperty(TextLabel.Property.TextDirection).Get(out temp);
 960                 return (TextDirection)temp;
 961             }
 962         }
 963
 964         /// <summary>
 965         /// The vertical line alignment of the text.
 966         /// </summary>
 967         /// <since_tizen> 5 </since_tizen>
 968         /// This will be released at Tizen.NET API Level 5, so currently this would be used as inhouse API.
 969         [EditorBrowsable(EditorBrowsableState.Never)]
 970         public VerticalLineAlignment VerticalLineAlignment
 971         {
 972             get
 973             {
 974                 return (VerticalLineAlignment)GetValue(VerticalLineAlignmentProperty);
 975             }
 976             set
 977             {
 978                 SetValue(VerticalLineAlignmentProperty, value);
 979                 NotifyPropertyChanged();
 980             }
 981         }
 982
 983         /// <summary>
 984         /// The text alignment to match the direction of the system language.
 985         /// </summary>
 986         /// <since_tizen> 6 </since_tizen>
 987         public bool MatchSystemLanguageDirection
 988         {
 989             get
 990             {
 991                 return (bool)GetValue(MatchSystemLanguageDirectionProperty);
 992             }
 993             set
 994             {
 995                 SetValue(MatchSystemLanguageDirectionProperty, value);
 996                 NotifyPropertyChanged();
 997             }
 998         }
 999
1000         /// <summary>
1001         /// The text fit parameters.<br />
1002         /// The textFit map contains the following keys :<br />
1003         /// <list type="table">
1004         /// <item><term>enable (bool)</term><description>True to enable the text fit or false to disable (the default value is false)</description></item>
1005         /// <item><term>minSize (float)</term><description>Minimum Size for text fit (the default value is 10.f)</description></item>
1006         /// <item><term>maxSize (float)</term><description>Maximum Size for text fit (the default value is 100.f)</description></item>
1007         /// <item><term>stepSize (float)</term><description>Step Size for font increase (the default value is 1.f)</description></item>
1008         /// <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>
1009         /// </list>
1010         /// </summary>
1011         /// This will be public opened in tizen_5.5 after ACR done. Before ACR, need to be hidden as inhouse API.
1012         [EditorBrowsable(EditorBrowsableState.Never)]
1013         public PropertyMap TextFit
1014         {
1015             get
1016             {
1017                 return (PropertyMap)GetValue(TextFitProperty);
1018             }
1019             set
1020             {
1021                 SetValue(TextFitProperty, value);
1022                 NotifyPropertyChanged();
1023             }
1024         }
1025
1026         /// <summary>
1027         /// The MinLineSize property.<br />
1028         /// </summary>
1029         /// <since_tizen> 8 </since_tizen>
1030         [EditorBrowsable(EditorBrowsableState.Never)]
1031         public float MinLineSize
1032         {
1033             get
1034             {
1035                 return (float)GetValue(MinLineSizeProperty);
1036             }
1037             set
1038             {
1039                 SetValue(MinLineSizeProperty, value);
1040                 NotifyPropertyChanged();
1041             }
1042         }
1043
1044         /// <summary>
1045         /// The FontSizeScale property. <br />
1046         /// The default value is 1.0. <br />
1047         /// If FontSizeScale.UseSystemSetting, will use the SystemSettings.FontSize internally. <br />
1048         /// </summary>
1049         /// <since_tizen> 9 </since_tizen>
1050         public float FontSizeScale
1051         {
1052             get
1053             {
1054                 return fontSizeScale;
1055             }
1056             set
1057             {
1058                 float newFontSizeScale;
1059
1060                 if (fontSizeScale == value) return;
1061
1062                 fontSizeScale = value;
1063                 if (fontSizeScale == Tizen.NUI.FontSizeScale.UseSystemSetting)
1064                 {
1065                     SystemSettingsFontSize systemSettingsFontSize;
1066
1067                     try
1068                     {
1069                         systemSettingsFontSize = SystemSettings.FontSize;
1070                     }
1071                     catch (Exception e)
1072                     {
1073                         Console.WriteLine("{0} Exception caught.", e);
1074                         systemSettingsFontSize = SystemSettingsFontSize.Normal;
1075                     }
1076                     newFontSizeScale = TextUtils.GetFontSizeScale(systemSettingsFontSize);
1077                     addFontSizeChangedCallback();
1078                 }
1079                 else
1080                 {
1081                     newFontSizeScale = fontSizeScale;
1082                     removeFontSizeChangedCallback();
1083                 }
1084
1085                 SetValue(FontSizeScaleProperty, newFontSizeScale);
1086                 NotifyPropertyChanged();
1087             }
1088         }
1089
1090         private TextLabelSelectorData EnsureSelectorData() => selectorData ?? (selectorData = new TextLabelSelectorData());
1091
1092         /// <summary>
1093         /// Downcasts a handle to textLabel handle
1094         /// </summary>
1095         /// <param name="handle"></param>
1096         /// <returns></returns>
1097         /// <exception cref="ArgumentNullException"> Thrown when handle is null. </exception>
1098         /// <since_tizen> 3 </since_tizen>
1099         /// Please do not use! this will be deprecated!
1100         /// Instead please use as keyword.
1101         [Obsolete("Please do not use! This will be deprecated! Please use as keyword instead! " +
1102             "Like: " +
1103             "BaseHandle handle = new TextLabel(\"Hello World!\"); " +
1104             "TextLabel label = handle as TextLabel")]
1105         [EditorBrowsable(EditorBrowsableState.Never)]
1106         public static TextLabel DownCast(BaseHandle handle)
1107         {
1108             if (null == handle)
1109             {
1110                 throw new ArgumentNullException(nameof(handle));
1111             }
1112             TextLabel ret = Registry.GetManagedBaseHandleFromNativePtr(handle) as TextLabel;
1113             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1114             return ret;
1115         }
1116
1117         /// <inheritdoc/>
1118         [EditorBrowsable(EditorBrowsableState.Never)]
1119         protected override void Dispose(DisposeTypes type)
1120         {
1121             if (disposed)
1122             {
1123                 return;
1124             }
1125
1126             if (systemlangTextFlag)
1127             {
1128                 SystemSettings.LocaleLanguageChanged -= SystemSettings_LocaleLanguageChanged;
1129             }
1130
1131             removeFontSizeChangedCallback();
1132
1133             if (type == DisposeTypes.Explicit)
1134             {
1135                 //Called by User
1136                 //Release your own managed resources here.
1137                 //You should release all of your own disposable objects here.
1138                 selectorData?.Reset(this);
1139             }
1140
1141             base.Dispose(type);
1142         }
1143
1144         internal static global::System.Runtime.InteropServices.HandleRef getCPtr(TextLabel obj)
1145         {
1146             return (obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.SwigCPtr;
1147         }
1148
1149         /// This will not be public opened.
1150         [EditorBrowsable(EditorBrowsableState.Never)]
1151         protected override void ReleaseSwigCPtr(System.Runtime.InteropServices.HandleRef swigCPtr)
1152         {
1153             Interop.TextLabel.DeleteTextLabel(swigCPtr);
1154         }
1155
1156         /// <summary>
1157         /// Get attribues, it is abstract function and must be override.
1158         /// </summary>
1159         [EditorBrowsable(EditorBrowsableState.Never)]
1160         protected override ViewStyle CreateViewStyle()
1161         {
1162             return new TextLabelStyle();
1163         }
1164
1165         /// <summary>
1166         /// Invoked whenever the binding context of the textlabel changes. Implement this method to add class handling for this event.
1167         /// </summary>
1168         protected override void OnBindingContextChanged()
1169         {
1170             base.OnBindingContextChanged();
1171         }
1172
1173         private void SystemSettings_LocaleLanguageChanged(object sender, LocaleLanguageChangedEventArgs e)
1174         {
1175             Text = NUIApplication.MultilingualResourceManager?.GetString(textLabelSid, new CultureInfo(e.Value.Replace("_", "-")));
1176         }
1177
1178         private void SystemSettingsFontSizeChanged(object sender, FontSizeChangedEventArgs e)
1179         {
1180             float newFontSizeScale = TextUtils.GetFontSizeScale(e.Value);
1181             SetValue(FontSizeScaleProperty, newFontSizeScale);
1182         }
1183
1184         private void addFontSizeChangedCallback()
1185         {
1186             if (hasFontSizeChangedCallback != true)
1187             {
1188                 try
1189                 {
1190                     SystemSettings.FontSizeChanged += SystemSettingsFontSizeChanged;
1191                     hasFontSizeChangedCallback = true;
1192                 }
1193                 catch (Exception e)
1194                 {
1195                     Console.WriteLine("{0} Exception caught.", e);
1196                     hasFontSizeChangedCallback = false;
1197                 }
1198             }
1199         }
1200
1201         private void removeFontSizeChangedCallback()
1202         {
1203             if (hasFontSizeChangedCallback == true)
1204             {
1205                 try
1206                 {
1207                     SystemSettings.FontSizeChanged -= SystemSettingsFontSizeChanged;
1208                     hasFontSizeChangedCallback = false;
1209                 }
1210                 catch (Exception e)
1211                 {
1212                     Console.WriteLine("{0} Exception caught.", e);
1213                     hasFontSizeChangedCallback = true;
1214                 }
1215             }
1216         }
1217
1218         private void RequestLayout()
1219         {
1220             Layout?.RequestLayout();
1221         }
1222
1223         internal new class Property
1224         {
1225             internal static readonly int TEXT = Interop.TextLabel.TextGet();
1226             internal static readonly int FontFamily = Interop.TextLabel.FontFamilyGet();
1227             internal static readonly int FontStyle = Interop.TextLabel.FontStyleGet();
1228             internal static readonly int PointSize = Interop.TextLabel.PointSizeGet();
1229             internal static readonly int MultiLine = Interop.TextLabel.MultiLineGet();
1230             internal static readonly int HorizontalAlignment = Interop.TextLabel.HorizontalAlignmentGet();
1231             internal static readonly int VerticalAlignment = Interop.TextLabel.VerticalAlignmentGet();
1232             internal static readonly int TextColor = Interop.TextLabel.TextColorGet();
1233             internal static readonly int EnableMarkup = Interop.TextLabel.EnableMarkupGet();
1234             internal static readonly int EnableAutoScroll = Interop.TextLabel.EnableAutoScrollGet();
1235             internal static readonly int AutoScrollSpeed = Interop.TextLabel.AutoScrollSpeedGet();
1236             internal static readonly int AutoScrollLoopCount = Interop.TextLabel.AutoScrollLoopCountGet();
1237             internal static readonly int AutoScrollGap = Interop.TextLabel.AutoScrollGapGet();
1238             internal static readonly int LineSpacing = Interop.TextLabel.LineSpacingGet();
1239             internal static readonly int UNDERLINE = Interop.TextLabel.UnderlineGet();
1240             internal static readonly int SHADOW = Interop.TextLabel.ShadowGet();
1241             internal static readonly int EMBOSS = Interop.TextLabel.EmbossGet();
1242             internal static readonly int OUTLINE = Interop.TextLabel.OutlineGet();
1243             internal static readonly int PixelSize = Interop.TextLabel.PixelSizeGet();
1244             internal static readonly int ELLIPSIS = Interop.TextLabel.EllipsisGet();
1245             internal static readonly int AutoScrollStopMode = Interop.TextLabel.AutoScrollStopModeGet();
1246             internal static readonly int AutoScrollLoopDelay = Interop.TextLabel.AutoScrollLoopDelayGet();
1247             internal static readonly int LineCount = Interop.TextLabel.LineCountGet();
1248             internal static readonly int LineWrapMode = Interop.TextLabel.LineWrapModeGet();
1249             internal static readonly int TextDirection = Interop.TextLabel.TextDirectionGet();
1250             internal static readonly int VerticalLineAlignment = Interop.TextLabel.VerticalLineAlignmentGet();
1251             internal static readonly int MatchSystemLanguageDirection = Interop.TextLabel.MatchSystemLanguageDirectionGet();
1252             internal static readonly int TextFit = Interop.TextLabel.TextFitGet();
1253             internal static readonly int MinLineSize = Interop.TextLabel.MinLineSizeGet();
1254             internal static readonly int FontSizeScale = Interop.TextLabel.FontSizeScaleGet();
1255             internal static readonly int EllipsisPosition = Interop.TextLabel.EllipsisPositionGet();
1256         }
1257
1258         private void OnShadowColorChanged(float x, float y, float z, float w)
1259         {
1260             ShadowColor = new Vector4(x, y, z, w);
1261         }
1262         private void OnShadowOffsetChanged(float x, float y)
1263         {
1264             ShadowOffset = new Vector2(x, y);
1265         }
1266         private void OnTextColorChanged(float r, float g, float b, float a)
1267         {
1268             TextColor = new Color(r, g, b, a);
1269         }
1270         private void OnUnderlineColorChanged(float x, float y, float z, float w)
1271         {
1272             UnderlineColor = new Vector4(x, y, z, w);
1273         }
1274     }
1275 }