更新

AntdWpf/Controls/Avatar.cs

@@ -0,0 +1,258 @@
+namespace AntdWpf.Controls
+{
+    using System.Windows;
+    using System.Windows.Controls;
+    using System.Windows.Markup;
+    using System.Windows.Media;
+    using ControlBase = System.Windows.Controls.Control;
+
+    /// <summary>
+    /// Avatars can be used to represent people or objects. It supports images, Icons, or letters.
+    /// </summary>
+    [ContentProperty("Text")]
+    [TemplatePart(Name = "PART_Content", Type = typeof(ContentPresenter))]
+    public class Avatar : ControlBase
+    {
+        #region Fields
+
+        private const string PART_Content = "PART_Content";
+
+        private ContentPresenter contentPresenter;
+
+        #endregion
+
+        #region Properties
+
+        public static readonly DependencyProperty IconProperty =
+            DependencyProperty.Register("Icon", typeof(string), typeof(Avatar), new PropertyMetadata(null, OnContentChanged));
+
+        /// <summary>
+        /// Gets/sets the icon type for an icon avatar.
+        /// </summary>
+        public string Icon
+        {
+            get { return (string)GetValue(IconProperty); }
+            set { SetValue(IconProperty, value); }
+        }
+
+        private static void OnContentChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
+        {
+            (d as Avatar).SetContent(true);
+        }
+
+        public static readonly DependencyProperty ShapeProperty =
+            DependencyProperty.Register("Shape", typeof(Shapes), typeof(Avatar), new PropertyMetadata(Shapes.Circle));
+
+        /// <summary>
+        /// Gets/sets the shape of avatar.
+        /// </summary>
+        public Shapes Shape
+        {
+            get { return (Shapes)GetValue(ShapeProperty); }
+            set { SetValue(ShapeProperty, value); }
+        }
+
+        public static readonly DependencyProperty SizeProperty =
+            DependencyProperty.Register("Size", typeof(Sizes?), typeof(Avatar), new PropertyMetadata(null, OnSizeChanged));
+
+        /// <summary>
+        /// Gets/sets the size of the avatar.
+        /// </summary>
+        public Sizes? Size
+        {
+            get { return (Sizes?)GetValue(SizeProperty); }
+            set { SetValue(SizeProperty, value); }
+        }
+
+        private static void OnSizeChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
+        {
+            var avatar = d as Avatar;
+            var newValue = (Sizes?)e.NewValue;
+            var oldValue = (Sizes?)e.OldValue;
+
+            if (newValue.HasValue && newValue.Value >= 0)
+            {
+                var size = (double)newValue.Value;
+                avatar.SetValue(WidthProperty, size);
+                avatar.SetValue(HeightProperty, size);
+                avatar.SetValue(FontSizeProperty, size / 2);
+            }
+            else if (oldValue.HasValue && oldValue.Value >= 0)
+            {
+                avatar.ClearValue(WidthProperty);
+                avatar.ClearValue(HeightProperty);
+                avatar.ClearValue(FontSizeProperty);
+            }
+        }
+
+        public static readonly DependencyProperty SourceProperty =
+            DependencyProperty.Register("Source", typeof(ImageSource), typeof(Avatar), new PropertyMetadata(null, OnContentChanged));
+
+        /// <summary>
+        /// Gets/sets the ImageSource for an image avatar.
+        /// </summary>
+        public ImageSource Source
+        {
+            get { return (ImageSource)GetValue(SourceProperty); }
+            set { SetValue(SourceProperty, value); }
+        }
+
+        public static readonly DependencyProperty TextProperty =
+            DependencyProperty.Register("Text", typeof(string), typeof(Avatar), new PropertyMetadata(string.Empty, OnContentChanged));
+
+        /// <summary>
+        /// Gets/sets the text for an text avatar.
+        /// </summary>
+        public string Text
+        {
+            get { return (string)GetValue(TextProperty); }
+            set { SetValue(TextProperty, value); }
+        }
+
+        public static readonly DependencyProperty AlternativeProperty =
+            DependencyProperty.Register("Alternative", typeof(string), typeof(Avatar), new PropertyMetadata(string.Empty));
+
+        /// <summary>
+        /// Gets/sets the alternative text describing the image.
+        /// </summary>
+        public string Alternative
+        {
+            get { return (string)GetValue(AlternativeProperty); }
+            set { SetValue(AlternativeProperty, value); }
+        }
+
+        public static readonly DependencyProperty IsImageProperty =
+            DependencyProperty.Register("IsImage", typeof(bool), typeof(Avatar), new PropertyMetadata(false));
+
+        /// <summary>
+        /// Gets the current avatar type as an image.
+        /// </summary>
+        public bool IsImage
+        {
+            get { return (bool)GetValue(IsImageProperty); }
+            private set { SetValue(IsImageProperty, value); }
+        }
+
+        #endregion
+
+        #region Constructors
+
+        static Avatar()
+        {
+            DefaultStyleKeyProperty.OverrideMetadata(typeof(Avatar), new FrameworkPropertyMetadata(typeof(Avatar)));
+        }
+
+        #endregion
+
+        #region Overrides
+
+        public override void OnApplyTemplate()
+        {
+            base.OnApplyTemplate();
+
+            contentPresenter = GetTemplateChild(PART_Content) as ContentPresenter;
+            SetContent(true);
+        }
+
+        #endregion
+
+        #region Private Methods
+
+        private void SetContent(bool imageExist)
+        {
+            if (contentPresenter == null) return;
+
+            var content = contentPresenter.Content;
+          
+            // Clear Event
+            if (content is Image)
+            {
+                ClearValue(IsImageProperty);
+                ((Image)content).ImageFailed -= OnImageFailed;
+            }
+            else if (content is TextBlock)
+            {
+                SizeChanged -= OnTextSizeChanged;
+                ((TextBlock)content).SizeChanged -= OnTextSizeChanged;
+            }
+
+            if (Source != null && imageExist)
+            {
+                if (!(content is Image))
+                {
+                    content = new Image();
+                }
+
+                SetCurrentValue(IsImageProperty, true);
+
+                var image = (Image)content;
+                image.Source = Source;
+
+                image.ImageFailed += OnImageFailed;
+                RenderOptions.SetBitmapScalingMode(image, BitmapScalingMode.HighQuality);
+
+            }
+            else if (Icon != null)
+            {
+                if (!(content is Icon))
+                {
+                    content = new Icon();
+                }
+
+                ((Icon)content).Type = Icon;
+            }
+            else
+            {
+                var text = string.IsNullOrEmpty(Text) ? (imageExist ? string.Empty : Alternative) : Text;
+
+                if (!(content is TextBlock))
+                {
+                    content = new TextBlock();
+                }
+
+                var textblock = (TextBlock)content;
+
+                SizeChanged += OnTextSizeChanged;
+                textblock.SizeChanged += OnTextSizeChanged;
+
+                textblock.Text = text;
+                textblock.RenderTransformOrigin = new Point(0.5, 0.5);
+            }
+
+            // 引用传递对 Null 无效
+            contentPresenter.Content = content;
+        }
+
+        private void OnImageFailed(object sender, ExceptionRoutedEventArgs e)
+        {
+            SetContent(false);
+        }
+
+        /// <summary>
+        /// Autoset Font Size
+        /// </summary>
+        /// <param name="sender"></param>
+        /// <param name="e"></param>
+        private void OnTextSizeChanged(object sender, SizeChangedEventArgs e)
+        {
+            if (contentPresenter != null && contentPresenter.Content is TextBlock textBlock)
+            {
+                var childrenWidth = textBlock.ActualWidth;
+                var width         = ActualWidth - 8;
+                var scale         = 1d;
+                var left          = 0d;
+
+                if (width < childrenWidth)
+                {
+                    scale = width / childrenWidth;
+                    left = ActualWidth / 2 - childrenWidth / 2;
+                }
+
+                textBlock.Margin = new Thickness(left, 0d, left, 0d);
+                textBlock.RenderTransform = new ScaleTransform(scale, scale);
+            }
+        }
+
+        #endregion
+    }
+}