diff options
Diffstat (limited to 'Xamarin.Forms.Core/Label.cs')
| -rw-r--r-- | Xamarin.Forms.Core/Label.cs | 270 |
1 files changed, 270 insertions, 0 deletions
diff --git a/Xamarin.Forms.Core/Label.cs b/Xamarin.Forms.Core/Label.cs new file mode 100644 index 00000000..fed021f8 --- /dev/null +++ b/Xamarin.Forms.Core/Label.cs @@ -0,0 +1,270 @@ +using System; +using System.ComponentModel; +using Xamarin.Forms.Platform; + +namespace Xamarin.Forms +{ + [ContentProperty("Text")] + [RenderWith(typeof(_LabelRenderer))] + public class Label : View, IFontElement + { + public static readonly BindableProperty HorizontalTextAlignmentProperty = BindableProperty.Create("HorizontalTextAlignment", typeof(TextAlignment), typeof(Label), TextAlignment.Start, + propertyChanged: OnHorizontalTextAlignmentPropertyChanged); + + [Obsolete("XAlignProperty is obsolete. Please use HorizontalTextAlignmentProperty instead.")] public static readonly BindableProperty XAlignProperty = HorizontalTextAlignmentProperty; + + public static readonly BindableProperty VerticalTextAlignmentProperty = BindableProperty.Create("VerticalTextAlignment", typeof(TextAlignment), typeof(Label), TextAlignment.Start, + propertyChanged: OnVerticalTextAlignmentPropertyChanged); + + [Obsolete("YAlignProperty is obsolete. Please use VerticalTextAlignmentProperty instead.")] public static readonly BindableProperty YAlignProperty = VerticalTextAlignmentProperty; + + public static readonly BindableProperty TextColorProperty = BindableProperty.Create("TextColor", typeof(Color), typeof(Label), Color.Default); + + public static readonly BindableProperty FontProperty = BindableProperty.Create("Font", typeof(Font), typeof(Label), default(Font), propertyChanged: FontStructPropertyChanged); + + public static readonly BindableProperty TextProperty = BindableProperty.Create("Text", typeof(string), typeof(Label), default(string), propertyChanged: OnTextPropertyChanged); + + public static readonly BindableProperty FontFamilyProperty = BindableProperty.Create("FontFamily", typeof(string), typeof(Label), default(string), propertyChanged: OnFontFamilyChanged); + + public static readonly BindableProperty FontSizeProperty = BindableProperty.Create("FontSize", typeof(double), typeof(Label), -1.0, propertyChanged: OnFontSizeChanged, + defaultValueCreator: bindable => Device.GetNamedSize(NamedSize.Default, (Label)bindable)); + + public static readonly BindableProperty FontAttributesProperty = BindableProperty.Create("FontAttributes", typeof(FontAttributes), typeof(Label), FontAttributes.None, + propertyChanged: OnFontAttributesChanged); + + public static readonly BindableProperty FormattedTextProperty = BindableProperty.Create("FormattedText", typeof(FormattedString), typeof(Label), default(FormattedString), + propertyChanging: (bindable, oldvalue, newvalue) => + { + if (oldvalue != null) + ((FormattedString)oldvalue).PropertyChanged -= ((Label)bindable).OnFormattedTextChanged; + }, propertyChanged: (bindable, oldvalue, newvalue) => + { + if (newvalue != null) + ((FormattedString)newvalue).PropertyChanged += ((Label)bindable).OnFormattedTextChanged; + ((Label)bindable).InvalidateMeasure(InvalidationTrigger.MeasureChanged); + if (newvalue != null) + ((Label)bindable).Text = null; + }); + + public static readonly BindableProperty LineBreakModeProperty = BindableProperty.Create("LineBreakMode", typeof(LineBreakMode), typeof(Label), LineBreakMode.WordWrap, + propertyChanged: (bindable, oldvalue, newvalue) => ((Label)bindable).InvalidateMeasure(InvalidationTrigger.MeasureChanged)); + + bool _cancelEvents; + + [Obsolete("Please use the Font attributes which are on the class itself. Obsoleted in v1.3.0")] + public Font Font + { + get { return (Font)GetValue(FontProperty); } + set { SetValue(FontProperty, value); } + } + + public FormattedString FormattedText + { + get { return (FormattedString)GetValue(FormattedTextProperty); } + set { SetValue(FormattedTextProperty, value); } + } + + public TextAlignment HorizontalTextAlignment + { + get { return (TextAlignment)GetValue(HorizontalTextAlignmentProperty); } + set { SetValue(HorizontalTextAlignmentProperty, value); } + } + + public LineBreakMode LineBreakMode + { + get { return (LineBreakMode)GetValue(LineBreakModeProperty); } + set { SetValue(LineBreakModeProperty, value); } + } + + public string Text + { + get { return (string)GetValue(TextProperty); } + set { SetValue(TextProperty, value); } + } + + public Color TextColor + { + get { return (Color)GetValue(TextColorProperty); } + set { SetValue(TextColorProperty, value); } + } + + public TextAlignment VerticalTextAlignment + { + get { return (TextAlignment)GetValue(VerticalTextAlignmentProperty); } + set { SetValue(VerticalTextAlignmentProperty, value); } + } + + [Obsolete("XAlign is obsolete. Please use HorizontalTextAlignment instead.")] + public TextAlignment XAlign + { + get { return (TextAlignment)GetValue(XAlignProperty); } + set { SetValue(XAlignProperty, value); } + } + + [Obsolete("YAlign is obsolete. Please use VerticalTextAlignment instead.")] + public TextAlignment YAlign + { + get { return (TextAlignment)GetValue(YAlignProperty); } + set { SetValue(YAlignProperty, value); } + } + + public FontAttributes FontAttributes + { + get { return (FontAttributes)GetValue(FontAttributesProperty); } + set { SetValue(FontAttributesProperty, value); } + } + + public string FontFamily + { + get { return (string)GetValue(FontFamilyProperty); } + set { SetValue(FontFamilyProperty, value); } + } + + [TypeConverter(typeof(FontSizeConverter))] + public double FontSize + { + get { return (double)GetValue(FontSizeProperty); } + set { SetValue(FontSizeProperty, value); } + } + + static void FontStructPropertyChanged(BindableObject bindable, object oldValue, object newValue) + { + var label = (Label)bindable; + if (label._cancelEvents) + return; + + label._cancelEvents = true; + + var font = (Font)newValue; + if (font == Font.Default) + { + label.FontFamily = null; + label.FontSize = Device.GetNamedSize(NamedSize.Default, label); + label.FontAttributes = FontAttributes.None; + } + else + { + label.FontFamily = font.FontFamily; + if (font.UseNamedSize) + { + label.FontSize = Device.GetNamedSize(font.NamedSize, label.GetType(), true); + } + else + { + label.FontSize = font.FontSize; + } + label.FontAttributes = font.FontAttributes; + } + + label._cancelEvents = false; + + label.InvalidateMeasure(InvalidationTrigger.MeasureChanged); + } + + static void OnFontAttributesChanged(BindableObject bindable, object oldValue, object newValue) + { + var label = (Label)bindable; + + if (label._cancelEvents) + return; + + label._cancelEvents = true; + + var attributes = (FontAttributes)newValue; + + object[] values = label.GetValues(FontFamilyProperty, FontSizeProperty); + var family = (string)values[0]; + if (family != null) + { + label.Font = Font.OfSize(family, (double)values[1]).WithAttributes(attributes); + } + else + { + label.Font = Font.SystemFontOfSize((double)values[1], attributes); + } + + label._cancelEvents = false; + + label.InvalidateMeasure(InvalidationTrigger.MeasureChanged); + } + + static void OnFontFamilyChanged(BindableObject bindable, object oldValue, object newValue) + { + var label = (Label)bindable; + if (label._cancelEvents) + return; + + label._cancelEvents = true; + + object[] values = label.GetValues(FontSizeProperty, FontAttributesProperty); + + var family = (string)newValue; + if (family != null) + { + label.Font = Font.OfSize(family, (double)values[0]).WithAttributes((FontAttributes)values[1]); + } + else + { + label.Font = Font.SystemFontOfSize((double)values[0], (FontAttributes)values[1]); + } + + label._cancelEvents = false; + label.InvalidateMeasure(InvalidationTrigger.MeasureChanged); + } + + static void OnFontSizeChanged(BindableObject bindable, object oldValue, object newValue) + { + var label = (Label)bindable; + if (label._cancelEvents) + return; + + label._cancelEvents = true; + + object[] values = label.GetValues(FontFamilyProperty, FontAttributesProperty); + + var size = (double)newValue; + var family = (string)values[0]; + if (family != null) + { + label.Font = Font.OfSize(family, size).WithAttributes((FontAttributes)values[1]); + } + else + { + label.Font = Font.SystemFontOfSize(size, (FontAttributes)values[1]); + } + + label._cancelEvents = false; + + label.InvalidateMeasure(InvalidationTrigger.MeasureChanged); + } + + void OnFormattedTextChanged(object sender, PropertyChangedEventArgs e) + { + OnPropertyChanged("FormattedText"); + } + + static void OnHorizontalTextAlignmentPropertyChanged(BindableObject bindable, object oldValue, object newValue) + { + var label = (Label)bindable; + label.OnPropertyChanged(nameof(XAlign)); + } + + static void OnTextPropertyChanged(BindableObject bindable, object oldvalue, object newvalue) + { + var label = (Label)bindable; + LineBreakMode breakMode = label.LineBreakMode; + bool isVerticallyFixed = (label.Constraint & LayoutConstraint.VerticallyFixed) != 0; + bool isSingleLine = !(breakMode == LineBreakMode.CharacterWrap || breakMode == LineBreakMode.WordWrap); + if (!isVerticallyFixed || !isSingleLine) + ((Label)bindable).InvalidateMeasure(InvalidationTrigger.MeasureChanged); + if (newvalue != null) + ((Label)bindable).FormattedText = null; + } + + static void OnVerticalTextAlignmentPropertyChanged(BindableObject bindable, object oldValue, object newValue) + { + var label = (Label)bindable; + label.OnPropertyChanged(nameof(YAlign)); + } + } +}
\ No newline at end of file |