Merge pull request #3 from HandyOrg/master

merge
2020-03-29 22:42:34 +08:00
commit 7ff1ed6fed
@@ -0,0 +1,110 @@
+using System;
+using System.Windows;
+using System.Windows.Controls;
+using System.Windows.Controls.Primitives;
+using HandyControl.Tools;
+using HandyControl.Tools.Interop;
+
+namespace HandyControl.Controls
+{
+    public class MenuTopLineAttach
+    {
+        public static readonly DependencyProperty PopupProperty = DependencyProperty.RegisterAttached(
+            "Popup", typeof(Popup), typeof(MenuTopLineAttach), new PropertyMetadata(default(Popup), OnPopupChanged));
+
+        private static void OnPopupChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
+        {
+            var topLine = (FrameworkElement) d;
+
+            if (e.NewValue is Popup popup)
+            {
+                if (popup.TemplatedParent is MenuItem menuItem)
+                {
+                    SetTopLine(menuItem, topLine);
+                    menuItem.Loaded += MenuItem_Loaded;
+                }
+            }
+        }
+
+        private static void MenuItem_Loaded(object sender, RoutedEventArgs e)
+        {
+            var menuItem = (FrameworkElement)sender;
+            menuItem.Unloaded += MenuItem_Unloaded;
+            var topLine = GetTopLine(menuItem);
+            var popup = GetPopup(topLine);
+            if (popup != null)
+            {
+                popup.Opened += Popup_Opened;
+            }
+        }
+
+        private static void MenuItem_Unloaded(object sender, RoutedEventArgs e)
+        {
+            var menuItem = (FrameworkElement)sender;
+            menuItem.Unloaded -= MenuItem_Unloaded;
+            var topLine = GetTopLine(menuItem);
+            var popup = GetPopup(topLine);
+            if (popup != null)
+            {
+                popup.Opened -= Popup_Opened;
+            }
+        }
+
+        private static void Popup_Opened(object sender, EventArgs e)
+        {
+            var popup = (Popup) sender;
+            if (popup.TemplatedParent is MenuItem menuItem)
+            {
+                var topLine = GetTopLine(menuItem);
+                if (topLine == null) return;
+
+                topLine.HorizontalAlignment = HorizontalAlignment.Left;
+                topLine.Width = menuItem.ActualWidth;
+                topLine.Margin = new Thickness();
+
+                var positionLeftTop = menuItem.PointToScreen(new Point());
+                var positionRightBottom = menuItem.PointToScreen(new Point(menuItem.ActualWidth, menuItem.ActualHeight));
+                ScreenHelper.FindMonitorRectsFromPoint(InteropMethods.GetCursorPos(), out _, out var workAreaRect);
+                var panel = VisualHelper.GetParent<Panel>(topLine);
+
+                if (positionLeftTop.X < 0)
+                {
+                    
+                    topLine.Margin = new Thickness(positionLeftTop.X - panel.Margin.Left, 0, 0, 0);
+                }
+                else if (positionLeftTop.X + panel.ActualWidth > workAreaRect.Right)
+                {
+                    var overflowWidth = positionRightBottom.X - workAreaRect.Right;
+                    if (overflowWidth > 0)
+                    {
+                        topLine.Width -= overflowWidth + panel.Margin.Right;
+                    }
+                    topLine.HorizontalAlignment = HorizontalAlignment.Left;
+                    topLine.Margin = new Thickness(positionLeftTop.X + panel.ActualWidth - workAreaRect.Right + panel.Margin.Right, 0, 0, 0);
+                }
+
+                if (positionRightBottom.Y > workAreaRect.Bottom)
+                {
+                    topLine.Width = 0;
+                    topLine.HorizontalAlignment = HorizontalAlignment.Stretch;
+                    topLine.Margin = new Thickness();
+                }
+            }
+        }
+
+        public static void SetPopup(DependencyObject element, Popup value)
+            => element.SetValue(PopupProperty, value);
+
+        public static Popup GetPopup(DependencyObject element)
+            => (Popup) element.GetValue(PopupProperty);
+
+        internal static readonly DependencyProperty TopLineProperty = DependencyProperty.RegisterAttached(
+            "TopLine", typeof(FrameworkElement), typeof(MenuTopLineAttach), new PropertyMetadata(default(FrameworkElement)));
+
+        internal static void SetTopLine(DependencyObject element, FrameworkElement value)
+            => element.SetValue(TopLineProperty, value);
+
+        internal static FrameworkElement GetTopLine(DependencyObject element)
+            => (FrameworkElement) element.GetValue(TopLineProperty);
+    }
+}
@@ -18,6 +18,8 @@ namespace HandyControl.Controls
    {
        private ProgressBar _progressBarBack;

+        private int _oriStepIndex = -1;
+
        #region Constants

        private const string ElementProgressBarBack = "PART_ProgressBarBack";
@@ -46,19 +48,14 @@ namespace HandyControl.Controls
                    }
                }

-                if (StepIndex < count)
+                if (_oriStepIndex > 0)
                {
-                    for (var i = 0; i < StepIndex; i++)
-                    {
-                        if (ItemContainerGenerator.ContainerFromIndex(i) is StepBarItem stepBarItem)
-                        {
-                            stepBarItem.Status = StepStatus.Complete;
-                        }
-                    }
-                    if (ItemContainerGenerator.ContainerFromIndex(StepIndex) is StepBarItem item)
-                    {
-                        item.Status = StepStatus.UnderWay;
-                    }
+                    StepIndex = _oriStepIndex;
+                    _oriStepIndex = -1;
+                }
+                else
+                {
+                    OnStepIndexChanged(StepIndex);
                }
            }
        }
@@ -85,12 +82,64 @@ namespace HandyControl.Controls
        }

        public static readonly DependencyProperty StepIndexProperty = DependencyProperty.Register(
-            "StepIndex", typeof(int), typeof(StepBar), new PropertyMetadata(ValueBoxes.Int0Box));
+            "StepIndex", typeof(int), typeof(StepBar), new FrameworkPropertyMetadata(ValueBoxes.Int0Box, 
+                FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnStepIndexChanged, CoerceStepIndex));
+
+        private static object CoerceStepIndex(DependencyObject d, object basevalue)
+        {
+            var ctl = (StepBar)d;
+            var stepIndex = (int) basevalue;
+            if (ctl.Items.Count == 0 && stepIndex > 0)
+            {
+                ctl._oriStepIndex = stepIndex;
+                return ValueBoxes.Int0Box;
+            }
+
+            return stepIndex < 0
+                ? ValueBoxes.Int0Box
+                : stepIndex >= ctl.Items.Count
+                    ? ctl.Items.Count == 0 ? 0 : ctl.Items.Count - 1
+                    : basevalue;
+        }
+
+        private static void OnStepIndexChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
+        {
+            var ctl = (StepBar) d;
+            ctl.OnStepIndexChanged((int)e.NewValue);
+        }
+
+        private void OnStepIndexChanged(int stepIndex)
+        {
+            for (var i = 0; i < stepIndex; i++)
+            {
+                if (ItemContainerGenerator.ContainerFromIndex(i) is StepBarItem stepItemFinished)
+                {
+                    stepItemFinished.Status = StepStatus.Complete;
+                }
+            }
+
+            for (var i = stepIndex + 1; i < Items.Count; i++)
+            {
+                if (ItemContainerGenerator.ContainerFromIndex(i) is StepBarItem stepItemFinished)
+                {
+                    stepItemFinished.Status = StepStatus.Waiting;
+                }
+            }
+
+            if (ItemContainerGenerator.ContainerFromIndex(stepIndex) is StepBarItem stepItemSelected)
+                stepItemSelected.Status = StepStatus.UnderWay;
+            _progressBarBack?.BeginAnimation(RangeBase.ValueProperty, AnimationHelper.CreateAnimation(stepIndex));
+            
+            RaiseEvent(new FunctionEventArgs<int>(StepChangedEvent, this)
+            {
+                Info = stepIndex
+            });
+        }

        public int StepIndex
        {
-            get => (int)GetValue(StepIndexProperty);
-            protected set => SetValue(StepIndexProperty, value);
+            get => (int)GetValue(StepIndexProperty); 
+            set => SetValue(StepIndexProperty, value);
        }

        public static readonly DependencyProperty DockProperty = DependencyProperty.Register(
@@ -128,42 +177,8 @@ namespace HandyControl.Controls
            }
        }

-        public void Next()
-        {
-            StepIndex++;
-            if (StepIndex >= Items.Count)
-            {
-                StepIndex = Items.Count - 1;
-                return;
-            }
-            RaiseEvent(new FunctionEventArgs<int>(StepChangedEvent, this)
-            {
-                Info = StepIndex
-            });
-            if (ItemContainerGenerator.ContainerFromIndex(StepIndex - 1) is StepBarItem stepItemFinished)
-                stepItemFinished.Status = StepStatus.Complete;
-            if (ItemContainerGenerator.ContainerFromIndex(StepIndex) is StepBarItem stepItemSelected)
-                stepItemSelected.Status = StepStatus.UnderWay;
-            _progressBarBack?.BeginAnimation(RangeBase.ValueProperty, AnimationHelper.CreateAnimation(StepIndex));
-        }
+        public void Next() => StepIndex++;

-        public void Prev()
-        {
-            StepIndex--;
-            if (StepIndex < 0)
-            {
-                StepIndex = 0;
-                return;
-            }
-            RaiseEvent(new FunctionEventArgs<int>(StepChangedEvent, this)
-            {
-                Info = StepIndex
-            });
-            if (ItemContainerGenerator.ContainerFromIndex(StepIndex + 1) is StepBarItem stepItemWaiting)
-                stepItemWaiting.Status = StepStatus.Waiting;
-            if (ItemContainerGenerator.ContainerFromIndex(StepIndex) is StepBarItem stepItemSelected)
-                stepItemSelected.Status = StepStatus.UnderWay;
-            _progressBarBack?.BeginAnimation(RangeBase.ValueProperty, AnimationHelper.CreateAnimation(StepIndex));
-        }
+        public void Prev() => StepIndex--;
    }
 }
@@ -251,6 +251,8 @@ namespace HandyControl.Controls
        protected override void OnMouseRightButtonDown(MouseButtonEventArgs e)
        {
            base.OnMouseRightButtonDown(e);
+
+            if (VisualTreeHelper.HitTest(this, e.GetPosition(this)) == null) return;
            IsSelected = true;
            Focus();
        }
@@ -293,6 +295,7 @@ namespace HandyControl.Controls
        {
            base.OnMouseLeftButtonDown(e);

+            if (VisualTreeHelper.HitTest(this, e.GetPosition(this)) == null) return;
            var parent = TabControlParent;
            if (parent == null) return;

@@ -155,24 +155,31 @@ namespace HandyControl.Controls

        protected override void OnRender(DrawingContext drawingContext)
        {
-            EnsureGeometry();
-
-            drawingContext.DrawGeometry(Fill, null, _textGeometry);
-
-            if (StrokePosition == StrokePosition.Outside)
+            if (StrokeThickness > 0)
            {
-                drawingContext.PushClip(_clipGeometry);
+                EnsureGeometry();
+
+                drawingContext.DrawGeometry(Fill, null, _textGeometry);
+
+                if (StrokePosition == StrokePosition.Outside)
+                {
+                    drawingContext.PushClip(_clipGeometry);
+                }
+                else if (StrokePosition == StrokePosition.Inside)
+                {
+                    drawingContext.PushClip(_textGeometry);
+                }
+
+                drawingContext.DrawGeometry(null, _pen, _textGeometry);
+
+                if (StrokePosition == StrokePosition.Outside || StrokePosition == StrokePosition.Inside)
+                {
+                    drawingContext.Pop();
+                }
            }
-            else if (StrokePosition == StrokePosition.Inside)
+            else
            {
-                drawingContext.PushClip(_textGeometry);
-            }
-
-            drawingContext.DrawGeometry(null, _pen, _textGeometry);
-
-            if (StrokePosition == StrokePosition.Outside || StrokePosition == StrokePosition.Inside)
-            {
-                drawingContext.Pop();
+                drawingContext.DrawText(_formattedText, new Point());
            }
        }

@@ -0,0 +1,203 @@
+using System;
+using System.ComponentModel;
+using System.Globalization;
+using System.Windows;
+using System.Windows.Documents;
+using System.Windows.Media;
+using HandyControl.Data;
+
+namespace HandyControl.Controls
+{
+    public class SimpleText : FrameworkElement
+    {
+        private FormattedText _formattedText;
+
+        static SimpleText()
+        {
+            SnapsToDevicePixelsProperty.OverrideMetadata(typeof(SimpleText), new FrameworkPropertyMetadata(ValueBoxes.TrueBox));
+            UseLayoutRoundingProperty.OverrideMetadata(typeof(SimpleText), new FrameworkPropertyMetadata(ValueBoxes.TrueBox));
+        }
+
+        public static readonly DependencyProperty TextProperty = DependencyProperty.Register(
+            "Text", typeof(string), typeof(SimpleText), new FrameworkPropertyMetadata(
+                string.Empty,
+                FrameworkPropertyMetadataOptions.AffectsMeasure |
+                FrameworkPropertyMetadataOptions.AffectsRender, OnFormattedTextInvalidated));
+
+        public string Text
+        {
+            get => (string)GetValue(TextProperty);
+            set => SetValue(TextProperty, value);
+        }
+
+        public static readonly DependencyProperty TextAlignmentProperty = DependencyProperty.Register(
+            "TextAlignment", typeof(TextAlignment), typeof(SimpleText),
+            new PropertyMetadata(default(TextAlignment), OnFormattedTextUpdated));
+
+        public TextAlignment TextAlignment
+        {
+            get => (TextAlignment)GetValue(TextAlignmentProperty);
+            set => SetValue(TextAlignmentProperty, value);
+        }
+
+        public static readonly DependencyProperty TextTrimmingProperty = DependencyProperty.Register(
+            "TextTrimming", typeof(TextTrimming), typeof(SimpleText),
+            new PropertyMetadata(default(TextTrimming), OnFormattedTextInvalidated));
+
+        public TextTrimming TextTrimming
+        {
+            get => (TextTrimming)GetValue(TextTrimmingProperty);
+            set => SetValue(TextTrimmingProperty, value);
+        }
+
+        public static readonly DependencyProperty TextWrappingProperty = DependencyProperty.Register(
+            "TextWrapping", typeof(TextWrapping), typeof(SimpleText),
+            new PropertyMetadata(TextWrapping.NoWrap, OnFormattedTextInvalidated));
+
+        public TextWrapping TextWrapping
+        {
+            get => (TextWrapping)GetValue(TextWrappingProperty);
+            set => SetValue(TextWrappingProperty, value);
+        }
+
+        public static readonly DependencyProperty ForegroundProperty = DependencyProperty.Register(
+            "Foreground", typeof(Brush), typeof(SimpleText), new PropertyMetadata(Brushes.Black, OnFormattedTextUpdated));
+
+        public Brush Foreground
+        {
+            get => (Brush) GetValue(ForegroundProperty);
+            set => SetValue(ForegroundProperty, value);
+        }
+
+        public static readonly DependencyProperty FontFamilyProperty = TextElement.FontFamilyProperty.AddOwner(
+            typeof(SimpleText),
+            new FrameworkPropertyMetadata(OnFormattedTextUpdated));
+
+        public FontFamily FontFamily
+        {
+            get => (FontFamily)GetValue(FontFamilyProperty);
+            set => SetValue(FontFamilyProperty, value);
+        }
+
+        public static readonly DependencyProperty FontSizeProperty = TextElement.FontSizeProperty.AddOwner(
+            typeof(SimpleText),
+            new FrameworkPropertyMetadata(OnFormattedTextUpdated));
+
+        [TypeConverter(typeof(FontSizeConverter))]
+        public double FontSize
+        {
+            get => (double)GetValue(FontSizeProperty);
+            set => SetValue(FontSizeProperty, value);
+        }
+
+        public static readonly DependencyProperty FontStretchProperty = TextElement.FontStretchProperty.AddOwner(
+            typeof(SimpleText),
+            new FrameworkPropertyMetadata(OnFormattedTextUpdated));
+
+        public FontStretch FontStretch
+        {
+            get => (FontStretch)GetValue(FontStretchProperty);
+            set => SetValue(FontStretchProperty, value);
+        }
+
+        public static readonly DependencyProperty FontStyleProperty = TextElement.FontStyleProperty.AddOwner(
+            typeof(SimpleText),
+            new FrameworkPropertyMetadata(OnFormattedTextUpdated));
+
+        public FontStyle FontStyle
+        {
+            get => (FontStyle)GetValue(FontStyleProperty);
+            set => SetValue(FontStyleProperty, value);
+        }
+
+        public static readonly DependencyProperty FontWeightProperty = TextElement.FontWeightProperty.AddOwner(
+            typeof(SimpleText),
+            new FrameworkPropertyMetadata(OnFormattedTextUpdated));
+
+        public FontWeight FontWeight
+        {
+            get => (FontWeight)GetValue(FontWeightProperty);
+            set => SetValue(FontWeightProperty, value);
+        }
+
+        protected override void OnRender(DrawingContext drawingContext) => drawingContext.DrawText(_formattedText, new Point());
+
+        private void EnsureFormattedText()
+        {
+            if (_formattedText != null || Text == null)
+            {
+                return;
+            }
+
+#if netle45
+            _formattedText = new FormattedText(
+                Text,
+                CultureInfo.CurrentUICulture,
+                FlowDirection,
+                new Typeface(FontFamily, FontStyle, FontWeight, FontStretch),
+                FontSize, Foreground);
+#else
+            var source = PresentationSource.FromVisual(this);
+            var dpi = 1.0;
+            if (source?.CompositionTarget != null)
+            {
+                dpi = 96.0 * source.CompositionTarget.TransformToDevice.M11 / 96.0;
+            }
+            _formattedText = new FormattedText(
+                Text,
+                CultureInfo.CurrentUICulture,
+                FlowDirection,
+                new Typeface(FontFamily, FontStyle, FontWeight, FontStretch),
+                FontSize, Foreground, dpi);
+#endif
+
+            UpdateFormattedText();
+        }
+
+        private void UpdateFormattedText()
+        {
+            if (_formattedText == null)
+            {
+                return;
+            }
+
+            _formattedText.MaxLineCount = TextWrapping == TextWrapping.NoWrap ? 1 : int.MaxValue;
+            _formattedText.TextAlignment = TextAlignment;
+            _formattedText.Trimming = TextTrimming;
+
+            _formattedText.SetFontSize(FontSize);
+            _formattedText.SetFontStyle(FontStyle);
+            _formattedText.SetFontWeight(FontWeight);
+            _formattedText.SetFontFamily(FontFamily);
+            _formattedText.SetFontStretch(FontStretch);
+        }
+
+        private static void OnFormattedTextUpdated(DependencyObject d, DependencyPropertyChangedEventArgs e)
+        {
+            var outlinedTextBlock = (SimpleText)d;
+            outlinedTextBlock.UpdateFormattedText();
+
+            outlinedTextBlock.InvalidateMeasure();
+            outlinedTextBlock.InvalidateVisual();
+        }
+
+        private static void OnFormattedTextInvalidated(DependencyObject d, DependencyPropertyChangedEventArgs e)
+        {
+            var outlinedTextBlock = (SimpleText)d;
+            outlinedTextBlock._formattedText = null;
+
+            outlinedTextBlock.InvalidateMeasure();
+            outlinedTextBlock.InvalidateVisual();
+        }
+
+        protected override Size MeasureOverride(Size availableSize)
+        {
+            EnsureFormattedText();
+
+            _formattedText.MaxTextWidth = Math.Min(3579139, availableSize.Width);
+            _formattedText.MaxTextHeight = Math.Max(0.0001d, availableSize.Height);
+
+            return new Size(_formattedText.Width, _formattedText.Height);
+        }
+    }
+}