support for .NET framework 3.5

Still have bugs

Net35/HandyControl_Net35/Controls/Attach/BackgroundSwitchElement.cs

@@ -0,0 +1,22 @@
+using System.Windows;
+using System.Windows.Media;
+
+namespace HandyControl.Controls
+{
+    public class BackgroundSwitchElement
+    {
+        public static readonly DependencyProperty MouseHoverBackgroundProperty = DependencyProperty.RegisterAttached(
+            "MouseHoverBackground", typeof(Brush), typeof(BackgroundSwitchElement), new FrameworkPropertyMetadata(Brushes.Transparent, FrameworkPropertyMetadataOptions.Inherits));
+
+        public static void SetMouseHoverBackground(DependencyObject element, Brush value) => element.SetValue(MouseHoverBackgroundProperty, value);
+
+        public static Brush GetMouseHoverBackground(DependencyObject element) => (Brush)element.GetValue(MouseHoverBackgroundProperty);
+
+        public static readonly DependencyProperty MouseDownBackgroundProperty = DependencyProperty.RegisterAttached(
+            "MouseDownBackground", typeof(Brush), typeof(BackgroundSwitchElement), new FrameworkPropertyMetadata(Brushes.Transparent, FrameworkPropertyMetadataOptions.Inherits));
+
+        public static void SetMouseDownBackground(DependencyObject element, Brush value) => element.SetValue(MouseDownBackgroundProperty, value);
+
+        public static Brush GetMouseDownBackground(DependencyObject element) => (Brush)element.GetValue(MouseDownBackgroundProperty);
+    }
+}

Net35/HandyControl_Net35/Controls/Attach/BorderElement.cs

@@ -0,0 +1,14 @@
+using System.Windows;
+
+namespace HandyControl.Controls
+{
+    public class BorderElement
+    {
+        public static readonly DependencyProperty CornerRadiusProperty = DependencyProperty.RegisterAttached(
+            "CornerRadius", typeof(CornerRadius), typeof(BorderElement), new FrameworkPropertyMetadata(default(CornerRadius), FrameworkPropertyMetadataOptions.Inherits));
+
+        public static void SetCornerRadius(DependencyObject element, CornerRadius value) => element.SetValue(CornerRadiusProperty, value);
+
+        public static CornerRadius GetCornerRadius(DependencyObject element) => (CornerRadius)element.GetValue(CornerRadiusProperty);
+    }
+}

Net35/HandyControl_Net35/Controls/Attach/EdgeElement.cs

@@ -0,0 +1,47 @@
+using System.Windows;
+using HandyControl.Data;
+
+namespace HandyControl.Controls
+{
+    public class EdgeElement
+    {
+        public static readonly DependencyProperty LeftContentProperty = DependencyProperty.RegisterAttached(
+            "LeftContent", typeof(object), typeof(EdgeElement), new PropertyMetadata(default(object), OnEdgeContentChanged));
+
+        public static void SetLeftContent(DependencyObject element, object value) => element.SetValue(LeftContentProperty, value);
+
+        public static object GetLeftContent(DependencyObject element) => element.GetValue(LeftContentProperty);
+
+        public static readonly DependencyProperty TopContentProperty = DependencyProperty.RegisterAttached(
+            "TopContent", typeof(object), typeof(EdgeElement), new PropertyMetadata(default(object), OnEdgeContentChanged));
+
+        public static void SetTopContent(DependencyObject element, object value) => element.SetValue(TopContentProperty, value);
+
+        public static object GetTopContent(DependencyObject element) => element.GetValue(TopContentProperty);
+
+        public static readonly DependencyProperty RightContentProperty = DependencyProperty.RegisterAttached(
+            "RightContent", typeof(object), typeof(EdgeElement), new PropertyMetadata(default(object), OnEdgeContentChanged));
+
+        public static void SetRightContent(DependencyObject element, object value) => element.SetValue(RightContentProperty, value);
+
+        public static object GetRightContent(DependencyObject element) => element.GetValue(RightContentProperty);
+
+        public static readonly DependencyProperty BottomContentProperty = DependencyProperty.RegisterAttached(
+            "BottomContent", typeof(object), typeof(EdgeElement), new PropertyMetadata(default(object), OnEdgeContentChanged));
+
+        public static void SetBottomContent(DependencyObject element, object value) => element.SetValue(BottomContentProperty, value);
+
+        public static object GetBottomContent(DependencyObject element) => element.GetValue(BottomContentProperty);
+
+        public static readonly DependencyProperty ShowEdgeContentProperty = DependencyProperty.RegisterAttached(
+            "ShowEdgeContent", typeof(bool), typeof(EdgeElement), new PropertyMetadata(ValueBoxes.FalseBox));
+
+        public static void SetShowEdgeContent(DependencyObject element, bool value) => element.SetValue(ShowEdgeContentProperty, value);
+
+        public static bool GetShowEdgeContent(DependencyObject element) => (bool) element.GetValue(ShowEdgeContentProperty);
+
+        private static void OnEdgeContentChanged(DependencyObject d, DependencyPropertyChangedEventArgs e) =>
+            SetShowEdgeContent(d, !(GetLeftContent(d) == null && GetTopContent(d) == null &&
+                                    GetRightContent(d) == null && GetBottomContent(d) == null));
+    }
+}

Net35/HandyControl_Net35/Controls/Attach/IconElement.cs

@@ -0,0 +1,35 @@
+using System.Windows;
+using System.Windows.Media;
+
+namespace HandyControl.Controls
+{
+    public class IconElement
+    {
+        public static readonly DependencyProperty GeometryProperty = DependencyProperty.RegisterAttached(
+            "Geometry", typeof(Geometry), typeof(IconElement), new PropertyMetadata(default(Geometry)));
+
+        public static void SetGeometry(DependencyObject element, Geometry value)
+            => element.SetValue(GeometryProperty, value);
+
+        public static Geometry GetGeometry(DependencyObject element) 
+            => (Geometry) element.GetValue(GeometryProperty);
+
+        public static readonly DependencyProperty WidthProperty = DependencyProperty.RegisterAttached(
+            "Width", typeof(double), typeof(IconElement), new PropertyMetadata(double.NaN));
+
+        public static void SetWidth(DependencyObject element, double value)
+            => element.SetValue(WidthProperty, value);
+
+        public static double GetWidth(DependencyObject element)
+            => (double) element.GetValue(WidthProperty);
+
+        public static readonly DependencyProperty HeightProperty = DependencyProperty.RegisterAttached(
+            "Height", typeof(double), typeof(IconElement), new PropertyMetadata(double.NaN));
+
+        public static void SetHeight(DependencyObject element, double value)
+            => element.SetValue(HeightProperty, value);
+
+        public static double GetHeight(DependencyObject element)
+            => (double) element.GetValue(HeightProperty);
+    }
+}

Net35/HandyControl_Net35/Controls/Attach/IconSwitchElement.cs

@@ -0,0 +1,21 @@
+using System.Windows;
+using System.Windows.Media;
+
+namespace HandyControl.Controls
+{
+    public class IconSwitchElement : IconElement
+    {
+        public static readonly DependencyProperty GeometrySelectedProperty = DependencyProperty.RegisterAttached(
+            "GeometrySelected", typeof(Geometry), typeof(IconSwitchElement), new PropertyMetadata(default(Geometry)));
+
+        public static void SetGeometrySelected(DependencyObject element, Geometry value)
+        {
+            element.SetValue(GeometrySelectedProperty, value);
+        }
+
+        public static Geometry GetGeometrySelected(DependencyObject element)
+        {
+            return (Geometry)element.GetValue(GeometrySelectedProperty);
+        }
+    }
+}

Net35/HandyControl_Net35/Controls/Attach/InfoElement.cs

@@ -0,0 +1,48 @@
+using System.Windows;
+using HandyControl.Data;
+
+namespace HandyControl.Controls
+{
+    public class InfoElement : TitleElement
+    {
+        /// <summary>
+        ///     占位符
+        /// </summary>
+        public static readonly DependencyProperty PlaceholderProperty = DependencyProperty.RegisterAttached(
+            "Placeholder", typeof(string), typeof(InfoElement), new FrameworkPropertyMetadata(default(string), FrameworkPropertyMetadataOptions.Inherits));
+
+        public static void SetPlaceholder(DependencyObject element, string value) => element.SetValue(PlaceholderProperty, value);
+
+        public static string GetPlaceholder(DependencyObject element) => (string)element.GetValue(PlaceholderProperty);
+
+        /// <summary>
+        ///     是否必填
+        /// </summary>
+        public static readonly DependencyProperty NecessaryProperty = DependencyProperty.RegisterAttached(
+            "Necessary", typeof(bool), typeof(InfoElement), new FrameworkPropertyMetadata(ValueBoxes.FalseBox, FrameworkPropertyMetadataOptions.Inherits));
+
+        public static void SetNecessary(DependencyObject element, bool value) => element.SetValue(NecessaryProperty, value);
+
+        public static bool GetNecessary(DependencyObject element) => (bool)element.GetValue(NecessaryProperty);
+
+        /// <summary>
+        ///     标记
+        /// </summary>
+        public static readonly DependencyProperty SymbolProperty = DependencyProperty.RegisterAttached(
+            "Symbol", typeof(string), typeof(InfoElement), new FrameworkPropertyMetadata(default(string), FrameworkPropertyMetadataOptions.Inherits));
+
+        public static void SetSymbol(DependencyObject element, string value) => element.SetValue(SymbolProperty, value);
+
+        public static string GetSymbol(DependencyObject element) => (string)element.GetValue(SymbolProperty);
+
+        /// <summary>
+        ///     内容高度
+        /// </summary>
+        public static readonly DependencyProperty ContentHeightProperty = DependencyProperty.RegisterAttached(
+            "ContentHeight", typeof(double), typeof(InfoElement), new FrameworkPropertyMetadata(30.0, FrameworkPropertyMetadataOptions.Inherits));
+
+        public static void SetContentHeight(DependencyObject element, double value) => element.SetValue(ContentHeightProperty, value);
+
+        public static double GetContentHeight(DependencyObject element) => (double)element.GetValue(ContentHeightProperty);
+    }
+}

Net35/HandyControl_Net35/Controls/Attach/LinkElement.cs

@@ -0,0 +1,47 @@
+using System.Diagnostics;
+using System.Windows;
+using System.Windows.Input;
+using HandyControl.Interactivity;
+
+namespace HandyControl.Controls
+{
+    public class LinkElement
+    {
+        public static readonly DependencyProperty LinkProperty = DependencyProperty.RegisterAttached(
+            "Link", typeof(string), typeof(LinkElement), new PropertyMetadata(default(string), OnLinkChanged));
+
+        private static void OnLinkChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
+        {
+            if (d is UIElement element)
+            {
+                CreateTrriger(element, (string) e.NewValue);
+            }
+        }
+
+        private static readonly DependencyProperty CommandBindingProperty = DependencyProperty.RegisterAttached(
+            "CommandBinding", typeof(CommandBinding), typeof(LinkElement), new PropertyMetadata(default(CommandBinding)));
+
+        private static void SetCommandBinding(DependencyObject element, CommandBinding value)
+            => element.SetValue(CommandBindingProperty, value);
+
+        private static CommandBinding GetCommandBinding(DependencyObject element)
+            => (CommandBinding) element.GetValue(CommandBindingProperty);
+
+        private static void CreateTrriger(UIElement element, string link)
+        {
+            element.CommandBindings.Remove(GetCommandBinding(element));
+            SetCommandBinding(element, null);
+
+            if (string.IsNullOrEmpty(link)) return;
+            var commandBinding = new CommandBinding(ControlCommands.OpenLink, (sender, args) => Process.Start(link));
+            SetCommandBinding(element, commandBinding);
+            element.CommandBindings.Add(commandBinding);
+        }
+
+        public static void SetLink(DependencyObject element, string value)
+            => element.SetValue(LinkProperty, value);
+
+        public static string GetLink(DependencyObject element)
+            => (string) element.GetValue(LinkProperty);
+    }
+}

Net35/HandyControl_Net35/Controls/Attach/PanelElement.cs

@@ -0,0 +1,43 @@
+using System.Windows;
+using System.Windows.Controls;
+using HandyControl.Interactivity;
+
+namespace HandyControl.Controls
+{
+    public class PanelElement
+    {
+        public static readonly DependencyProperty FluidMoveBehaviorProperty = DependencyProperty.RegisterAttached(
+            "FluidMoveBehavior", typeof(FluidMoveBehavior), typeof(PanelElement), new PropertyMetadata(default(FluidMoveBehavior), OnFluidMoveBehaviorChanged));
+
+        private static void OnFluidMoveBehaviorChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
+        {
+            if (d is Panel panel)
+            {                
+                var collection = Interaction.GetBehaviors(panel);
+                var oldBehavior = GetTempFluidMoveBehavior(panel);
+                collection.Remove(oldBehavior);
+
+                if (e.NewValue is FluidMoveBehavior behavior)
+                {
+                    collection.Add(behavior);
+                    SetTempFluidMoveBehavior(panel, behavior);
+                }
+            }
+        }
+
+        public static void SetFluidMoveBehavior(DependencyObject element, FluidMoveBehavior value)
+            => element.SetValue(FluidMoveBehaviorProperty, value);
+
+        public static FluidMoveBehavior GetFluidMoveBehavior(DependencyObject element)
+            => (FluidMoveBehavior) element.GetValue(FluidMoveBehaviorProperty);
+
+        private static readonly DependencyProperty TempFluidMoveBehaviorProperty = DependencyProperty.RegisterAttached(
+            "TempFluidMoveBehavior", typeof(FluidMoveBehavior), typeof(PanelElement), new PropertyMetadata(default(FluidMoveBehavior)));
+
+        private static void SetTempFluidMoveBehavior(DependencyObject element, FluidMoveBehavior value)
+            => element.SetValue(TempFluidMoveBehaviorProperty, value);
+
+        private static FluidMoveBehavior GetTempFluidMoveBehavior(DependencyObject element)
+            => (FluidMoveBehavior) element.GetValue(TempFluidMoveBehaviorProperty);
+    }
+}

Net35/HandyControl_Net35/Controls/Attach/PasswordBoxMonitor.cs

@@ -0,0 +1,54 @@
+using System.Windows;
+using HandyControl.Data;
+
+namespace HandyControl.Controls
+{
+    public class PasswordBoxMonitor
+    {
+        /// <summary>
+        ///     密码长度
+        /// </summary>
+        public static readonly DependencyProperty PasswordLengthProperty = DependencyProperty.RegisterAttached(
+            "PasswordLength", typeof(int), typeof(PasswordBoxMonitor), new PropertyMetadata(default(int)));
+
+        public static void SetPasswordLength(DependencyObject element, int value) => element.SetValue(PasswordLengthProperty, value);
+
+        public static int GetPasswordLength(DependencyObject element) => (int)element.GetValue(PasswordLengthProperty);
+
+        /// <summary>
+        ///     是否监测
+        /// </summary>
+        public static readonly DependencyProperty IsMonitoringProperty = DependencyProperty.RegisterAttached(
+            "IsMonitoring", typeof(bool), typeof(PasswordBoxMonitor), new FrameworkPropertyMetadata(ValueBoxes.FalseBox, FrameworkPropertyMetadataOptions.Inherits, OnIsMonitoringChanged));
+
+        private static void OnIsMonitoringChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
+        {
+            if (d is System.Windows.Controls.PasswordBox passwordBox)
+            {
+                if (e.NewValue is bool boolValue)
+                {
+                    if (boolValue)
+                    {
+                        passwordBox.PasswordChanged += PasswordChanged;
+                    }
+                    else
+                    {
+                        passwordBox.PasswordChanged -= PasswordChanged;
+                    }
+                }
+            }
+        }
+
+        public static void SetIsMonitoring(DependencyObject element, bool value) => element.SetValue(IsMonitoringProperty, value);
+
+        public static bool GetIsMonitoring(DependencyObject element) => (bool)element.GetValue(IsMonitoringProperty);
+
+        private static void PasswordChanged(object sender, RoutedEventArgs e)
+        {
+            if (sender is System.Windows.Controls.PasswordBox passwordBox)
+            {
+                SetPasswordLength(passwordBox, passwordBox.Password.Length);
+            }
+        }
+    }
+}

Net35/HandyControl_Net35/Controls/Attach/StatusSwitchElement.cs

@@ -0,0 +1,28 @@
+using System.Windows;
+using HandyControl.Data;
+
+namespace HandyControl.Controls
+{
+    public class StatusSwitchElement
+    {
+        /// <summary>
+        ///     选中时展示的元素
+        /// </summary>
+        public static readonly DependencyProperty CheckedElementProperty = DependencyProperty.RegisterAttached(
+            "CheckedElement", typeof(object), typeof(StatusSwitchElement), new PropertyMetadata(default(object)));
+
+        public static void SetCheckedElement(DependencyObject element, object value) => element.SetValue(CheckedElementProperty, value);
+
+        public static object GetCheckedElement(DependencyObject element) => element.GetValue(CheckedElementProperty);
+
+        /// <summary>
+        ///     是否隐藏元素
+        /// </summary>
+        public static readonly DependencyProperty HiddenElementProperty = DependencyProperty.RegisterAttached(
+            "HiddenElement", typeof(bool), typeof(StatusSwitchElement), new PropertyMetadata(ValueBoxes.FalseBox));
+
+        public static void SetHiddenElement(DependencyObject element, bool value) => element.SetValue(HiddenElementProperty, value);
+
+        public static bool GetHiddenElement(DependencyObject element) => (bool) element.GetValue(HiddenElementProperty);
+    }
+}

Net35/HandyControl_Net35/Controls/Attach/TipElement.cs

@@ -0,0 +1,22 @@
+using System.Windows;
+using HandyControl.Data;
+
+namespace HandyControl.Controls
+{
+    public class TipElement
+    {
+        public static readonly DependencyProperty VisibilityProperty = DependencyProperty.RegisterAttached(
+            "Visibility", typeof(Visibility), typeof(TipElement), new PropertyMetadata(Visibility.Collapsed));
+
+        public static void SetVisibility(DependencyObject element, Visibility value) => element.SetValue(VisibilityProperty, value);
+
+        public static Visibility GetVisibility(DependencyObject element) => (Visibility) element.GetValue(VisibilityProperty);
+
+        public static readonly DependencyProperty PlacementProperty = DependencyProperty.RegisterAttached(
+            "Placement", typeof(TipPlacement), typeof(TipElement), new PropertyMetadata(default(TipPlacement)));
+
+        public static void SetPlacement(DependencyObject element, TipPlacement value) => element.SetValue(PlacementProperty, value);
+
+        public static TipPlacement GetPlacement(DependencyObject element) => (TipPlacement) element.GetValue(PlacementProperty);
+    }
+}

Net35/HandyControl_Net35/Controls/Attach/TitleElement.cs

@@ -0,0 +1,67 @@
+using System.Windows;
+using System.Windows.Media;
+using HandyControl.Data;
+
+namespace HandyControl.Controls
+{
+    public class TitleElement
+    {
+        public static readonly DependencyProperty TitleProperty = DependencyProperty.RegisterAttached(
+            "Title", typeof(string), typeof(TitleElement), new PropertyMetadata(default(string)));
+
+        public static void SetTitle(DependencyObject element, string value)
+            => element.SetValue(TitleProperty, value);
+
+        public static string GetTitle(DependencyObject element)
+            => (string) element.GetValue(TitleProperty);
+
+        public static readonly DependencyProperty BackgroundProperty = DependencyProperty.RegisterAttached(
+            "Background", typeof(Brush), typeof(TitleElement), new FrameworkPropertyMetadata(default(Brush), FrameworkPropertyMetadataOptions.Inherits));
+
+        public static void SetBackground(DependencyObject element, Brush value)
+            => element.SetValue(BackgroundProperty, value);
+
+        public static Brush GetBackground(DependencyObject element)
+            => (Brush) element.GetValue(BackgroundProperty);
+
+        public static readonly DependencyProperty ForegroundProperty = DependencyProperty.RegisterAttached(
+            "Foreground", typeof(Brush), typeof(TitleElement), new FrameworkPropertyMetadata(default(Brush), FrameworkPropertyMetadataOptions.Inherits));
+
+        public static void SetForeground(DependencyObject element, Brush value)
+            => element.SetValue(ForegroundProperty, value);
+
+        public static Brush GetForeground(DependencyObject element)
+            => (Brush) element.GetValue(ForegroundProperty);
+
+        public static readonly DependencyProperty BorderBrushProperty = DependencyProperty.RegisterAttached(
+            "BorderBrush", typeof(Brush), typeof(TitleElement), new FrameworkPropertyMetadata(default(Brush), FrameworkPropertyMetadataOptions.Inherits));
+
+        public static void SetBorderBrush(DependencyObject element, Brush value)
+            => element.SetValue(BorderBrushProperty, value);
+
+        public static Brush GetBorderBrush(DependencyObject element)
+            => (Brush) element.GetValue(BorderBrushProperty);
+
+        /// <summary>
+        ///     标题对齐方式
+        /// </summary>
+        public static readonly DependencyProperty TitleAlignmentProperty = DependencyProperty.RegisterAttached(
+            "TitleAlignment", typeof(TitleAlignment), typeof(TitleElement), new FrameworkPropertyMetadata(TitleAlignment.Top, FrameworkPropertyMetadataOptions.Inherits));
+
+        public static void SetTitleAlignment(DependencyObject element, TitleAlignment value)
+            => element.SetValue(TitleAlignmentProperty, value);
+
+        public static TitleAlignment GetTitleAlignment(DependencyObject element)
+            => (TitleAlignment) element.GetValue(TitleAlignmentProperty);
+
+        /// <summary>
+        ///     标题宽度
+        /// </summary>
+        public static readonly DependencyProperty TitleWidthProperty = DependencyProperty.RegisterAttached(
+            "TitleWidth", typeof(GridLength), typeof(TitleElement), new FrameworkPropertyMetadata(new GridLength(120.0), FrameworkPropertyMetadataOptions.Inherits));
+
+        public static void SetTitleWidth(DependencyObject element, GridLength value) => element.SetValue(TitleWidthProperty, value);
+
+        public static GridLength GetTitleWidth(DependencyObject element) => (GridLength)element.GetValue(TitleWidthProperty);
+    }
+}

Net35/HandyControl_Net35/Controls/Attach/VisualElement.cs

@@ -0,0 +1,17 @@
+using System.Windows;
+using System.Windows.Media;
+
+namespace HandyControl.Controls
+{
+    public class VisualElement
+    {
+        public static readonly DependencyProperty HighlightBrushProperty = DependencyProperty.RegisterAttached(
+            "HighlightBrush", typeof(Brush), typeof(VisualElement), new PropertyMetadata(default(Brush)));
+
+        public static void SetHighlightBrush(DependencyObject element, Brush value)
+            => element.SetValue(HighlightBrushProperty, value);
+
+        public static Brush GetHighlightBrush(DependencyObject element)
+            => (Brush) element.GetValue(HighlightBrushProperty);
+    }
+}

Net35/HandyControl_Net35/Controls/Attach/WindowAttach.cs

@@ -0,0 +1,41 @@
+using System.Windows;
+using System.Windows.Input;
+using HandyControl.Data;
+
+namespace HandyControl.Controls
+{
+    public static class WindowAttach
+    {
+        public static readonly DependencyProperty IsDragElementProperty = DependencyProperty.RegisterAttached(
+            "IsDragElement", typeof(bool), typeof(WindowAttach), new PropertyMetadata(ValueBoxes.FalseBox, OnIsDragElementChanged));
+
+        public static void SetIsDragElement(DependencyObject element, bool value)
+            => element.SetValue(IsDragElementProperty, value);
+
+        public static bool GetIsDragElement(DependencyObject element)
+            => (bool) element.GetValue(IsDragElementProperty);
+
+        private static void OnIsDragElementChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
+        {
+            if (d is UIElement ctl)
+            {
+                if ((bool)e.NewValue)
+                {
+                    ctl.MouseLeftButtonDown += DragElement_MouseLeftButtonDown;
+                }
+                else
+                {
+                    ctl.MouseLeftButtonDown -= DragElement_MouseLeftButtonDown;
+                }
+            }
+        }
+
+        private static void DragElement_MouseLeftButtonDown(object sender, MouseButtonEventArgs e)
+        {
+            if (sender is DependencyObject obj && e.ButtonState == MouseButtonState.Pressed)
+            {
+                System.Windows.Window.GetWindow(obj)?.DragMove();
+            }
+        }
+    }
+}