.net copy

BrightSharp.NET/Diagrams/Adorners/ResizeRotateAdorner.cs

@@ -0,0 +1,48 @@
+using System.ComponentModel;
+using System.Windows;
+using System.Windows.Controls;
+using System.Windows.Documents;
+using System.Windows.Media;
+
+namespace BrightSharp.Diagrams
+{
+    [ToolboxItem(false)]
+    public class ResizeRotateAdorner : Adorner
+    {
+        private VisualCollection visuals;
+        private ResizeRotateChrome chrome;
+
+        protected override int VisualChildrenCount
+        {
+            get
+            {
+                return visuals.Count;
+            }
+        }
+
+        public ResizeRotateAdorner(ContentControl designerItem)
+            : base(designerItem)
+        {
+            SnapsToDevicePixels = true;
+            chrome = new ResizeRotateChrome();
+            chrome.DataContext = designerItem;
+            visuals = new VisualCollection(this);
+            visuals.Add(chrome);
+            Focusable = true;
+        }
+
+
+
+        protected override Size ArrangeOverride(Size arrangeBounds)
+        {
+            chrome.Arrange(new Rect(arrangeBounds));
+            return arrangeBounds;
+        }
+
+        protected override Visual GetVisualChild(int index)
+        {
+            return visuals[index];
+        }
+        
+    }
+}

BrightSharp.NET/Diagrams/Adorners/ResizeRotateChrome.cs

@@ -0,0 +1,15 @@
+using System.ComponentModel;
+using System.Windows;
+using System.Windows.Controls;
+
+namespace BrightSharp.Diagrams
+{
+    [ToolboxItem(false)]
+    public class ResizeRotateChrome : Control
+    {
+        static ResizeRotateChrome()
+        {
+            FrameworkElement.DefaultStyleKeyProperty.OverrideMetadata(typeof(ResizeRotateChrome), new FrameworkPropertyMetadata(typeof(ResizeRotateChrome)));
+        }
+    }
+}

BrightSharp.NET/Diagrams/Adorners/SizeAdorner.cs

@@ -0,0 +1,46 @@
+using System.ComponentModel;
+using System.Windows;
+using System.Windows.Controls;
+using System.Windows.Documents;
+using System.Windows.Media;
+
+namespace BrightSharp.Diagrams
+{
+    [ToolboxItem(false)]
+    public class SizeAdorner : Adorner
+    {
+        private SizeChrome chrome;
+        private VisualCollection visuals;
+        private FrameworkElement designerItem;
+
+        protected override int VisualChildrenCount
+        {
+            get
+            {
+                return visuals.Count;
+            }
+        }
+
+        public SizeAdorner(FrameworkElement designerItem)
+            : base(designerItem)
+        {
+            SnapsToDevicePixels = true;
+            this.designerItem = designerItem;
+            chrome = new SizeChrome();
+            chrome.DataContext = designerItem;
+            visuals = new VisualCollection(this);
+            visuals.Add(chrome);
+        }
+
+        protected override Visual GetVisualChild(int index)
+        {
+            return visuals[index];
+        }
+
+        protected override Size ArrangeOverride(Size arrangeBounds)
+        {
+            chrome.Arrange(new Rect(new Point(0.0, 0.0), arrangeBounds));
+            return arrangeBounds;
+        }
+    }
+}

BrightSharp.NET/Diagrams/Adorners/SizeChrome.cs

@@ -0,0 +1,34 @@
+using System;
+using System.ComponentModel;
+using System.Globalization;
+using System.Windows;
+using System.Windows.Controls;
+using System.Windows.Data;
+
+namespace BrightSharp.Diagrams
+{
+
+    [ToolboxItem(false)]
+    public class SizeChrome : Control
+    {
+        static SizeChrome()
+        {
+            DefaultStyleKeyProperty.OverrideMetadata(typeof(SizeChrome), new FrameworkPropertyMetadata(typeof(SizeChrome)));
+        }
+    }
+
+    public class DoubleFormatConverter : IValueConverter
+    {
+        public object Convert(object value, Type targetType, object parameter, CultureInfo culture)
+        {
+            double d = (double)value;
+            if (double.IsNaN(d)) return "(Auto)";
+            return Math.Round(d);
+        }
+
+        public object ConvertBack(object value, Type targetType, object parameter, CultureInfo culture)
+        {
+            return null;
+        }
+    }
+}

BrightSharp.NET/Diagrams/DesignerItemDecorator.cs

@@ -0,0 +1,103 @@
+using System;
+using System.Windows.Controls;
+using System.Windows.Documents;
+using System.Windows;
+using System.Windows.Media;
+using System.Windows.Media.Animation;
+using System.ComponentModel;
+
+namespace BrightSharp.Diagrams
+{
+    [ToolboxItem(false)]
+    public class DesignerItemDecorator : Control
+    {
+        private Adorner adorner;
+
+        public bool ShowDecorator
+        {
+            get { return (bool)GetValue(ShowDecoratorProperty); }
+            set { SetValue(ShowDecoratorProperty, value); }
+        }
+
+        public static readonly DependencyProperty ShowDecoratorProperty =
+            DependencyProperty.Register("ShowDecorator", typeof(bool), typeof(DesignerItemDecorator),
+            new FrameworkPropertyMetadata(false, new PropertyChangedCallback(ShowDecoratorProperty_Changed)));
+
+        public DesignerItemDecorator()
+        {
+            Unloaded += new RoutedEventHandler(DesignerItemDecorator_Unloaded);
+        }
+
+        private void HideAdorner()
+        {
+            if (adorner != null)
+            {
+                adorner.Visibility = Visibility.Hidden;
+            }
+        }
+
+        private void ShowAdorner()
+        {
+            if (adorner == null)
+            {
+                AdornerLayer adornerLayer = AdornerLayer.GetAdornerLayer(this);
+
+                if (adornerLayer != null)
+                {
+                    ContentControl designerItem = DataContext as ContentControl;
+                    Canvas canvas = VisualTreeHelper.GetParent(designerItem) as Canvas;
+                    adorner = new ResizeRotateAdorner(designerItem);
+                    adornerLayer.Add(adorner);
+
+                    if (ShowDecorator)
+                    {
+                        adorner.Visibility = Visibility.Visible;
+
+                        var anim = new DoubleAnimation(0, 1, TimeSpan.FromSeconds(.2));
+                        adorner.BeginAnimation(OpacityProperty, anim);
+                    }
+                    else
+                    {
+                        adorner.Visibility = Visibility.Hidden;
+                    }
+                }
+            }
+            else
+            {
+                adorner.Visibility = Visibility.Visible;
+
+                var anim = new DoubleAnimation(0, 1, TimeSpan.FromSeconds(.2));
+                adorner.BeginAnimation(OpacityProperty, anim);
+            }
+        }
+
+        private void DesignerItemDecorator_Unloaded(object sender, RoutedEventArgs e)
+        {
+            if (adorner != null)
+            {
+                AdornerLayer adornerLayer = AdornerLayer.GetAdornerLayer(this);
+                if (adornerLayer != null)
+                {
+                    adornerLayer.Remove(adorner);
+                }
+
+                adorner = null;
+            }
+        }
+
+        private static void ShowDecoratorProperty_Changed(DependencyObject d, DependencyPropertyChangedEventArgs e)
+        {
+            DesignerItemDecorator decorator = (DesignerItemDecorator)d;
+            bool showDecorator = (bool)e.NewValue;
+
+            if (showDecorator)
+            {
+                decorator.ShowAdorner();
+            }
+            else
+            {
+                decorator.HideAdorner();
+            }
+        }
+    }
+}

BrightSharp.NET/Diagrams/SelectionBehavior.cs

@@ -0,0 +1,96 @@
+using BrightSharp.Extensions;
+using System.Linq;
+using System.Windows;
+using System.Windows.Controls;
+using System.Windows.Controls.Primitives;
+
+namespace BrightSharp.Diagrams
+{
+    public static class SelectionBehavior
+    {
+        public static void Attach(FrameworkElement fe)
+        {
+            FrameworkElement selectedControl = null;
+            Style designerStyle = (Style)Application.Current.FindResource("DesignerItemStyle");
+            if (fe is Panel)
+            {
+                var fePanel = (Panel)fe;
+                fe.PreviewMouseLeftButtonDown += (s, e) =>
+                {
+                    if (e.Source is DependencyObject)
+                    {
+                        var clickedElement = ((DependencyObject)e.OriginalSource).GetAncestors<ContentControl>().FirstOrDefault(el => el.Style == designerStyle && WpfExtensions.GetItemsPanel(el.GetParent(true)) == fe);
+                        if (clickedElement == null)
+                        {
+                            foreach (DependencyObject item in fePanel.Children)
+                            {
+                                Selector.SetIsSelected(item, false);
+                            }
+                            selectedControl = null;
+                            return;
+                        }
+                        foreach (var control in fePanel.Children.OfType<FrameworkElement>())
+                        {
+                            if (ProcessControl(control, clickedElement, ref selectedControl))
+                            {
+                                if (selectedControl is ContentControl cc && cc.Content is ButtonBase)
+                                {
+                                    e.Handled = true;
+                                    return;
+                                }
+                            }
+                        }
+
+                    }
+                };
+            }
+            else if (fe is ItemsControl)
+            {
+                var feItemsControl = (ItemsControl)fe;
+                fe.PreviewMouseLeftButtonDown += (s, e) =>
+                {
+                    if (e.Source is DependencyObject)
+                    {
+                        var clickedElement = ((DependencyObject)e.Source).GetAncestors<ContentControl>().FirstOrDefault(el => el.Style == designerStyle && el.Parent == fe);
+                        if (clickedElement == null)
+                        {
+                            foreach (DependencyObject item in feItemsControl.Items)
+                            {
+                                Selector.SetIsSelected(item, false);
+                            }
+                            selectedControl = null;
+                            return;
+                        }
+                        foreach (var control in feItemsControl.Items.OfType<FrameworkElement>())
+                        {
+                            if (ProcessControl(control, clickedElement, ref selectedControl))
+                            {
+                                if (selectedControl is ContentControl cc && cc.Content is ButtonBase)
+                                {
+                                    e.Handled = true;
+                                    return;
+                                }
+                            }
+                        }
+
+                    }
+                };
+            }
+        }
+
+        private static bool ProcessControl(FrameworkElement control, FrameworkElement clickedElement, ref FrameworkElement selectedControl)
+        {
+            if (control == clickedElement && control != selectedControl)
+            {
+                if (selectedControl != null)
+                {
+                    Selector.SetIsSelected(selectedControl, false);
+                }
+                Selector.SetIsSelected(control, true);
+                selectedControl = control;
+                return true;
+            }
+            return false;
+        }
+    }
+}

BrightSharp.NET/Diagrams/Thumbs/MoveThumb.cs

@@ -0,0 +1,75 @@
+using System;
+using System.ComponentModel;
+using System.Windows;
+using System.Windows.Controls;
+using System.Windows.Controls.Primitives;
+using System.Windows.Media;
+
+namespace BrightSharp.Diagrams
+{
+    [ToolboxItem(false)]
+    public class MoveThumb : Thumb
+    {
+        private RotateTransform rotateTransform;
+        private FrameworkElement designerItem;
+        private static int? zIndex = null;
+
+        public MoveThumb()
+        {
+            DragStarted += MoveThumb_DragStarted;
+            DragDelta += MoveThumb_DragDelta;
+            DragCompleted += MoveThumb_DragCompleted;
+        }
+
+        private void MoveThumb_DragCompleted(object sender, DragCompletedEventArgs e)
+        {
+            //TODO Need think about ZIndex changes
+        }
+
+        private void MoveThumb_DragStarted(object sender, DragStartedEventArgs e)
+        {
+            designerItem = DataContext as FrameworkElement;
+
+            if (designerItem != null)
+            {
+                rotateTransform = designerItem.RenderTransform as RotateTransform;
+                if (designerItem.GetBindingExpression(Panel.ZIndexProperty) == null)
+                {
+                    zIndex = Math.Max(zIndex ?? 0, Panel.GetZIndex(designerItem));
+                    Panel.SetZIndex(designerItem, zIndex.Value + 1);
+                }
+            }
+        }
+
+        private void MoveThumb_DragDelta(object sender, DragDeltaEventArgs e)
+        {
+            if (designerItem != null)
+            {
+                Point dragDelta = new Point(e.HorizontalChange, e.VerticalChange);
+
+                double gridSize = 0;
+
+                var zoomControl = designerItem.Parent as ZoomControl;
+                if (zoomControl != null) gridSize = zoomControl.GridSize;
+
+                if (rotateTransform != null)
+                {
+                    dragDelta = rotateTransform.Transform(dragDelta);
+                }
+                if (double.IsNaN(Canvas.GetLeft(designerItem))) Canvas.SetLeft(designerItem, 0);
+                if (double.IsNaN(Canvas.GetTop(designerItem))) Canvas.SetTop(designerItem, 0);
+
+                var newLeft = Canvas.GetLeft(designerItem) + dragDelta.X;
+                var newTop = Canvas.GetTop(designerItem) + dragDelta.Y;
+                if (gridSize > 0)
+                {
+                    newLeft = Math.Truncate(newLeft / gridSize) * gridSize;
+                    newTop = Math.Truncate(newTop / gridSize) * gridSize;
+                }
+                Canvas.SetLeft(designerItem, newLeft);
+                Canvas.SetTop(designerItem, newTop);
+
+            }
+        }
+    }
+}

BrightSharp.NET/Diagrams/Thumbs/ResizeThumb.cs

@@ -0,0 +1,160 @@
+using System;
+using System.Windows;
+using System.Windows.Controls;
+using System.Windows.Controls.Primitives;
+using System.Windows.Documents;
+using System.Windows.Media;
+using System.Windows.Input;
+using System.ComponentModel;
+
+namespace BrightSharp.Diagrams
+{
+    [ToolboxItem(false)]
+    public class ResizeThumb : Thumb
+    {
+        private RotateTransform rotateTransform;
+        private double angle;
+        private Adorner adorner;
+        private Point transformOrigin;
+        private FrameworkElement designerItem;
+        private FrameworkElement canvas;
+
+        public ResizeThumb()
+        {
+            DragStarted += new DragStartedEventHandler(ResizeThumb_DragStarted);
+            DragDelta += new DragDeltaEventHandler(ResizeThumb_DragDelta);
+            DragCompleted += new DragCompletedEventHandler(ResizeThumb_DragCompleted);
+            MouseRightButtonDown += new MouseButtonEventHandler(ResizeThumb_MouseRightButtonDown);
+        }
+
+        private void ResizeThumb_MouseRightButtonDown(object sender, MouseButtonEventArgs e)
+        {
+            designerItem = designerItem ?? DataContext as FrameworkElement;
+
+            if (VerticalAlignment == VerticalAlignment.Top || VerticalAlignment == VerticalAlignment.Bottom)
+            {
+                designerItem.Height = double.NaN;
+            }
+            if (HorizontalAlignment == HorizontalAlignment.Left || HorizontalAlignment == HorizontalAlignment.Right)
+            {
+                designerItem.Width = double.NaN;
+            }
+        }
+
+        private void ResizeThumb_DragStarted(object sender, DragStartedEventArgs e)
+        {
+            designerItem = DataContext as ContentControl;
+
+            if (designerItem != null)
+            {
+                canvas = VisualTreeHelper.GetParent(designerItem) as FrameworkElement;
+
+                if (canvas != null)
+                {
+                    transformOrigin = designerItem.RenderTransformOrigin;
+
+                    rotateTransform = designerItem.RenderTransform as RotateTransform;
+                    if (rotateTransform != null)
+                    {
+                        angle = rotateTransform.Angle * Math.PI / 180.0;
+                    }
+                    else
+                    {
+                        angle = 0.0d;
+                    }
+
+                    AdornerLayer adornerLayer = AdornerLayer.GetAdornerLayer(canvas);
+                    if (adornerLayer != null)
+                    {
+                        adorner = new SizeAdorner(designerItem);
+                        adornerLayer.Add(adorner);
+                    }
+                }
+            }
+        }
+
+        private void ResizeThumb_DragDelta(object sender, DragDeltaEventArgs e)
+        {
+            if (designerItem != null)
+            {
+                double deltaVertical, deltaHorizontal;
+                if (double.IsNaN(Canvas.GetTop(designerItem))) Canvas.SetTop(designerItem, 0);
+                if (double.IsNaN(Canvas.GetLeft(designerItem))) Canvas.SetLeft(designerItem, 0);
+                if ((VerticalAlignment == VerticalAlignment.Top || VerticalAlignment == VerticalAlignment.Bottom) && double.IsNaN(designerItem.Height)) designerItem.Height = designerItem.ActualHeight;
+                if ((HorizontalAlignment == HorizontalAlignment.Left || HorizontalAlignment == HorizontalAlignment.Right) && double.IsNaN(designerItem.Width)) designerItem.Width = designerItem.ActualWidth;
+
+                var zoomControl = designerItem.Parent as dynamic;
+                double.TryParse(zoomControl.Tag as string, out var gridSize);
+
+                var verticalChange = e.VerticalChange;
+                var horizontalChange = e.HorizontalChange;
+
+                if (gridSize > 0)
+                {
+                    verticalChange = Math.Truncate(verticalChange / gridSize) * gridSize;
+                    horizontalChange = Math.Truncate(horizontalChange / gridSize) * gridSize;
+                }
+                if (verticalChange != 0)
+                {
+                    switch (VerticalAlignment)
+                    {
+                        case System.Windows.VerticalAlignment.Bottom:
+                            deltaVertical = Math.Min(-verticalChange, designerItem.ActualHeight - designerItem.MinHeight);
+                            deltaVertical = Math.Max(deltaVertical, designerItem.ActualHeight - designerItem.MaxHeight);
+                            Canvas.SetTop(designerItem, Canvas.GetTop(designerItem) + (transformOrigin.Y * deltaVertical * (1 - Math.Cos(-angle))));
+                            Canvas.SetLeft(designerItem, Canvas.GetLeft(designerItem) - deltaVertical * transformOrigin.Y * Math.Sin(-angle));
+                            designerItem.Height -= deltaVertical;
+                            break;
+                        case System.Windows.VerticalAlignment.Top:
+                            deltaVertical = Math.Min(verticalChange, designerItem.ActualHeight - designerItem.MinHeight);
+                            deltaVertical = Math.Max(deltaVertical, designerItem.ActualHeight - designerItem.MaxHeight);
+                            Canvas.SetTop(designerItem, Canvas.GetTop(designerItem) + deltaVertical * Math.Cos(-angle) + (transformOrigin.Y * deltaVertical * (1 - Math.Cos(-angle))));
+                            Canvas.SetLeft(designerItem, Canvas.GetLeft(designerItem) + deltaVertical * Math.Sin(-angle) - (transformOrigin.Y * deltaVertical * Math.Sin(-angle)));
+                            designerItem.Height -= deltaVertical;
+                            break;
+                        default:
+                            break;
+                    }
+                }
+                if (horizontalChange != 0)
+                {
+                    switch (HorizontalAlignment)
+                    {
+                        case System.Windows.HorizontalAlignment.Left:
+                            deltaHorizontal = Math.Min(horizontalChange, designerItem.ActualWidth - designerItem.MinWidth);
+                            deltaHorizontal = Math.Max(deltaHorizontal, designerItem.ActualWidth - designerItem.MaxWidth);
+                            Canvas.SetTop(designerItem, Canvas.GetTop(designerItem) + deltaHorizontal * Math.Sin(angle) - transformOrigin.X * deltaHorizontal * Math.Sin(angle));
+                            Canvas.SetLeft(designerItem, Canvas.GetLeft(designerItem) + deltaHorizontal * Math.Cos(angle) + (transformOrigin.X * deltaHorizontal * (1 - Math.Cos(angle))));
+                            designerItem.Width -= deltaHorizontal;
+                            break;
+                        case System.Windows.HorizontalAlignment.Right:
+                            deltaHorizontal = Math.Min(-horizontalChange, designerItem.ActualWidth - designerItem.MinWidth);
+                            deltaHorizontal = Math.Max(deltaHorizontal, designerItem.ActualWidth - designerItem.MaxWidth);
+                            Canvas.SetTop(designerItem, Canvas.GetTop(designerItem) - transformOrigin.X * deltaHorizontal * Math.Sin(angle));
+                            Canvas.SetLeft(designerItem, Canvas.GetLeft(designerItem) + (deltaHorizontal * transformOrigin.X * (1 - Math.Cos(angle))));
+                            designerItem.Width -= deltaHorizontal;
+                            break;
+                        default:
+                            break;
+                    }
+                }
+            }
+
+            e.Handled = true;
+        }
+
+        private void ResizeThumb_DragCompleted(object sender, DragCompletedEventArgs e)
+        {
+            if (adorner != null)
+            {
+                AdornerLayer adornerLayer = AdornerLayer.GetAdornerLayer(canvas);
+                if (adornerLayer != null)
+                {
+                    adornerLayer.Remove(adorner);
+                }
+
+                adorner = null;
+            }
+        }
+    }
+}

BrightSharp.NET/Diagrams/Thumbs/RotateThumb.cs

@@ -0,0 +1,88 @@
+using System;
+using System.ComponentModel;
+using System.Windows;
+using System.Windows.Controls;
+using System.Windows.Controls.Primitives;
+using System.Windows.Input;
+using System.Windows.Media;
+
+namespace BrightSharp.Diagrams
+{
+    [ToolboxItem(false)]
+    public class RotateThumb : Thumb
+    {
+        private double initialAngle;
+        private RotateTransform rotateTransform;
+        private Vector startVector;
+        private Point centerPoint;
+        private ContentControl designerItem;
+        private Canvas canvas;
+
+        public RotateThumb()
+        {
+            DragDelta += new DragDeltaEventHandler(RotateThumb_DragDelta);
+            DragStarted += new DragStartedEventHandler(RotateThumb_DragStarted);
+            MouseRightButtonDown += RotateThumb_MouseLeftButtonDown;
+        }
+
+        private void RotateThumb_MouseLeftButtonDown(object sender, MouseButtonEventArgs e)
+        {
+            if (e.RightButton == MouseButtonState.Pressed)
+            {
+                rotateTransform = designerItem.RenderTransform as RotateTransform;
+                if (rotateTransform != null)
+                {
+                    rotateTransform.Angle = 0;
+                    designerItem.InvalidateMeasure();
+                }
+            }
+        }
+
+        private void RotateThumb_DragStarted(object sender, DragStartedEventArgs e)
+        {
+            designerItem = DataContext as ContentControl;
+
+            if (designerItem != null)
+            {
+                canvas = VisualTreeHelper.GetParent(designerItem) as Canvas;
+
+                if (canvas != null)
+                {
+                    centerPoint = designerItem.TranslatePoint(
+                        new Point(designerItem.ActualWidth * designerItem.RenderTransformOrigin.X,
+                                  designerItem.ActualHeight * designerItem.RenderTransformOrigin.Y),
+                                  canvas);
+
+                    Point startPoint = Mouse.GetPosition(canvas);
+                    startVector = Point.Subtract(startPoint, centerPoint);
+
+                    rotateTransform = designerItem.RenderTransform as RotateTransform;
+                    if (rotateTransform == null)
+                    {
+                        designerItem.RenderTransform = new RotateTransform(0);
+                        initialAngle = 0;
+                    }
+                    else
+                    {
+                        initialAngle = rotateTransform.Angle;
+                    }
+                }
+            }
+        }
+
+        private void RotateThumb_DragDelta(object sender, DragDeltaEventArgs e)
+        {
+            if (designerItem != null && canvas != null)
+            {
+                Point currentPoint = Mouse.GetPosition(canvas);
+                Vector deltaVector = Point.Subtract(currentPoint, centerPoint);
+
+                double angle = Vector.AngleBetween(startVector, deltaVector);
+
+                RotateTransform rotateTransform = designerItem.RenderTransform as RotateTransform;
+                rotateTransform.Angle = initialAngle + Math.Round(angle, 0);
+                designerItem.InvalidateMeasure();
+            }
+        }
+    }
+}

BrightSharp.NET/Diagrams/VisualExtensions.cs

@@ -0,0 +1,132 @@
+using BrightSharp.Extensions;
+using System;
+using System.Globalization;
+using System.Windows;
+using System.Windows.Media;
+using System.Windows.Media.Animation;
+
+namespace BrightSharp.Diagrams
+{
+    /// <summary>
+    /// If starts with a(A) then use animation,
+    /// $FromZoom-$ToZoom pattern
+    /// </summary>
+    public class VisualExtensions : DependencyObject
+    {
+        #region LevelOfDetails Attached Property
+
+        public static readonly DependencyProperty LODZoomProperty =
+            DependencyProperty.RegisterAttached("LODZoom",
+            typeof(string),
+            typeof(VisualExtensions),
+            new UIPropertyMetadata(null, OnChangeLODZoomProperty));
+
+        public static void SetLODZoom(UIElement element, string o)
+        {
+            element.SetValue(LODZoomProperty, o);
+        }
+
+        public static string GetLODZoom(UIElement element)
+        {
+            return (string)element.GetValue(LODZoomProperty);
+        }
+        #endregion
+
+        public static bool GetCanRotate(DependencyObject obj) {
+            return (bool)obj.GetValue(CanRotateProperty);
+        }
+
+        public static void SetCanRotate(DependencyObject obj, bool value) {
+            obj.SetValue(CanRotateProperty, value);
+        }
+
+        public static readonly DependencyProperty CanRotateProperty =
+            DependencyProperty.RegisterAttached("CanRotate", typeof(bool), typeof(VisualExtensions), new FrameworkPropertyMetadata(true, FrameworkPropertyMetadataOptions.Inherits));
+
+        private static void OnChangeLODZoomProperty(DependencyObject d, DependencyPropertyChangedEventArgs e)
+        {
+            var element = d as FrameworkElement;
+            if (element == null) return;
+
+            var window = Window.GetWindow(element);
+            if (window == null) return;
+
+            if (e.NewValue != e.OldValue)
+            {
+                var zoomControl = element.FindAncestor<ZoomControl>();
+                if (zoomControl == null) return;
+
+                var zoomChangedHandler = new RoutedEventHandler((sender, args) =>
+                {
+                    try {
+                        ChangeVisibility(args, element, window);
+                    }
+                    catch (Exception) {
+                    }
+                });
+
+
+                if (string.IsNullOrWhiteSpace((string)e.NewValue))
+                {
+                    element.Opacity = 1;
+                    zoomControl.ZoomChanged -= zoomChangedHandler;
+                    zoomControl.Loaded -= zoomChangedHandler;
+                }
+                else
+                {
+                    zoomControl.ZoomChanged += zoomChangedHandler;
+                    zoomControl.Loaded += zoomChangedHandler;
+                }
+            }
+        }
+
+        private static void ChangeVisibility(RoutedEventArgs args, FrameworkElement element, Window window) {
+            var lodInfo = new LodInfo(GetLODZoom(element));
+
+            var transform = element.TransformToVisual(window) as MatrixTransform;
+            var scaleX = transform.Matrix.M11;
+
+            var newOpacity = (scaleX >= lodInfo.StartRange && scaleX <= lodInfo.EndRange) ? 1 : 0;
+
+            if (lodInfo.UseAnimation && args.RoutedEvent != FrameworkElement.LoadedEvent) {
+                element.Visibility = Visibility.Visible;
+                var animation = new DoubleAnimation(newOpacity, TimeSpan.FromSeconds(.5));
+                element.BeginAnimation(UIElement.OpacityProperty, animation);
+            }
+            else {
+                element.Visibility = newOpacity == 1 ? Visibility.Visible : Visibility.Hidden;
+                element.Opacity = newOpacity;
+            }
+        }
+
+        sealed class LodInfo
+        {
+            public LodInfo(string lod)
+            {
+                lod = lod.TrimStart();
+                UseAnimation = lod.StartsWith("a", true, CultureInfo.InvariantCulture);
+                lod = lod.TrimStart('a', 'A').Trim();
+
+                double rangeStart = 0;
+                double rangeEnd = double.PositiveInfinity;
+                var vals = lod.Split('-');
+
+                double.TryParse(vals[0], NumberStyles.AllowDecimalPoint, CultureInfo.InvariantCulture, out rangeStart);
+
+                if (vals.Length > 1)
+                {
+                    if (!double.TryParse(vals[1], NumberStyles.AllowDecimalPoint, CultureInfo.InvariantCulture, out rangeEnd))
+                    {
+                        rangeEnd = double.PositiveInfinity;
+                    }
+                }
+                EndRange = rangeEnd;
+                StartRange = rangeStart;
+            }
+            public double StartRange { get; set; }
+            public double EndRange { get; set; }
+            public bool UseAnimation { get; set; }
+        }
+    }
+
+}

BrightSharp.NET/Diagrams/ZoomControl.cs

@@ -0,0 +1,228 @@
+using BrightSharp.Extensions;
+using System;
+using System.Windows;
+using System.Windows.Controls;
+using System.Windows.Documents;
+using System.Windows.Input;
+using System.Windows.Media.Animation;
+
+namespace BrightSharp.Diagrams
+{
+
+    public partial class ZoomControl : ItemsControl
+    {
+        public ZoomControl()
+        {
+            Loaded += ZoomControl_Loaded;
+
+        }
+
+        private void ZoomControl_Loaded(object sender, RoutedEventArgs e)
+        {
+            SelectionBehavior.Attach(this);
+        }
+        
+        public ContentControl SelectedControl
+        {
+            get { return (ContentControl)GetValue(SelectedControlProperty); }
+            set { SetValue(SelectedControlProperty, value); }
+        }
+
+        public static readonly DependencyProperty SelectedControlProperty =
+            DependencyProperty.Register("SelectedControl", typeof(ContentControl), typeof(ZoomControl), new PropertyMetadata(null));
+
+        protected override void OnPreviewMouseDown(MouseButtonEventArgs e)
+        {
+            base.OnPreviewMouseDown(e);
+
+            if (e.MiddleButton == MouseButtonState.Pressed)
+            {
+                _panPoint = e.GetPosition(this);
+            }
+        }
+
+        private Point? _panPoint;
+
+        #region Props
+
+        public double TranslateX
+        {
+            get { return (double)GetValue(TranslateXProperty); }
+            set { SetValue(TranslateXProperty, value); }
+        }
+
+        public static readonly DependencyProperty TranslateXProperty =
+            DependencyProperty.Register("TranslateX", typeof(double), typeof(ZoomControl), new FrameworkPropertyMetadata(0.0, FrameworkPropertyMetadataOptions.AffectsArrange, TranslateChangedHandler));
+
+
+
+        public double TranslateY
+        {
+            get { return (double)GetValue(TranslateYProperty); }
+            set { SetValue(TranslateYProperty, value); }
+        }
+
+        public static readonly DependencyProperty TranslateYProperty =
+            DependencyProperty.Register("TranslateY", typeof(double), typeof(ZoomControl), new FrameworkPropertyMetadata(0.0, FrameworkPropertyMetadataOptions.AffectsArrange, TranslateChangedHandler));
+
+
+
+        public double GridSize
+        {
+            get { return (double)GetValue(GridSizeProperty); }
+            set { SetValue(GridSizeProperty, value); }
+        }
+
+        public static readonly DependencyProperty GridSizeProperty =
+            DependencyProperty.Register("GridSize", typeof(double), typeof(ZoomControl), new PropertyMetadata(0.0));
+
+        public double RenderZoom
+        {
+            get { return (double)GetValue(RenderZoomProperty); }
+            set { SetValue(RenderZoomProperty, value); }
+        }
+
+        public static readonly DependencyProperty RenderZoomProperty =
+            DependencyProperty.Register("RenderZoom", typeof(double), typeof(ZoomControl), new FrameworkPropertyMetadata(1.0, FrameworkPropertyMetadataOptions.AffectsArrange, ZoomChangedHandler));
+
+        private static void ZoomChangedHandler(DependencyObject d, DependencyPropertyChangedEventArgs baseValue)
+        {
+            ZoomControl zc = (ZoomControl)d;
+        }
+        private static void TranslateChangedHandler(DependencyObject d, DependencyPropertyChangedEventArgs baseValue)
+        {
+            ZoomControl zc = (ZoomControl)d;
+        }
+
+        #endregion
+
+        private static readonly RoutedEvent ZoomChangedEvent = EventManager.RegisterRoutedEvent("ZoomChanged", RoutingStrategy.Bubble, typeof(RoutedEventHandler), typeof(ZoomControl));
+
+        public event RoutedEventHandler ZoomChanged
+        {
+            add { AddHandler(ZoomChangedEvent, value); }
+            remove { RemoveHandler(ZoomChangedEvent, value); }
+        }
+
+        private void RaiseZoomChangedEvent()
+        {
+            var newEventArgs = new RoutedEventArgs(ZoomChangedEvent);
+            RaiseEvent(newEventArgs);
+        }
+
+        static ZoomControl()
+        {
+            DefaultStyleKeyProperty.OverrideMetadata(typeof(ZoomControl), new FrameworkPropertyMetadata(typeof(ZoomControl)));
+        }
+
+        protected override void OnPreviewMouseWheel(MouseWheelEventArgs e)
+        {
+            if (CheckMouseOverControlWheelHandle(_panPoint.HasValue))
+                return;
+
+            var point = e.GetPosition(this);
+
+
+            var oldValue = RenderZoom;
+            const double zoomPower = 1.25;
+            var newValue = RenderZoom * (e.Delta > 0 ? zoomPower : 1 / zoomPower);
+            if (UseAnimation)
+            {
+                DoubleAnimation anim = new DoubleAnimation(newValue, TimeSpan.FromSeconds(.3));
+                anim.EasingFunction = new SineEase() { EasingMode = EasingMode.EaseInOut };
+                BeginAnimation(ZoomControl.RenderZoomProperty, anim);
+            }
+            else 
+            {
+                DoubleAnimation anim = new DoubleAnimation(newValue, TimeSpan.FromSeconds(0));
+                anim.EasingFunction = new SineEase() { EasingMode = EasingMode.EaseInOut };
+                BeginAnimation(ZoomControl.RenderZoomProperty, anim);
+            }
+
+            RaiseZoomChangedEvent();
+
+            var translateXTo = CoercePanTranslate(TranslateX, point.X, oldValue, newValue);
+            var translateYTo = CoercePanTranslate(TranslateY, point.Y, oldValue, newValue);
+            if (UseAnimation)
+            {
+                DoubleAnimation anim = new DoubleAnimation(translateXTo, TimeSpan.FromSeconds(.3));
+                anim.EasingFunction = new SineEase() { EasingMode = EasingMode.EaseInOut };
+                BeginAnimation(ZoomControl.TranslateXProperty, anim);
+
+                anim = new DoubleAnimation(translateYTo, TimeSpan.FromSeconds(.3));
+                anim.EasingFunction = new SineEase() { EasingMode = EasingMode.EaseInOut };
+                BeginAnimation(ZoomControl.TranslateYProperty, anim);
+            }
+            else
+            {
+                DoubleAnimation anim = new DoubleAnimation(translateXTo, TimeSpan.FromSeconds(0));
+                anim.EasingFunction = new SineEase() { EasingMode = EasingMode.EaseInOut };
+                BeginAnimation(ZoomControl.TranslateXProperty, anim);
+
+                anim = new DoubleAnimation(translateYTo, TimeSpan.FromSeconds(0));
+                anim.EasingFunction = new SineEase() { EasingMode = EasingMode.EaseInOut };
+                BeginAnimation(ZoomControl.TranslateYProperty, anim);
+            }
+
+            e.Handled = true;
+
+            base.OnPreviewMouseWheel(e);
+        }
+        public bool UseAnimation { get; set; }
+        private static bool CheckMouseOverControlWheelHandle(bool checkFlowDoc = false)
+        {
+            if (Keyboard.IsKeyDown(Key.LeftCtrl)) return false;
+            var element = Mouse.DirectlyOver as DependencyObject;
+            if (element is ScrollViewer) return true;
+
+            var scrollViewer = element.FindAncestor<ScrollViewer>();
+            if (scrollViewer != null)
+            {
+                return scrollViewer.ComputedVerticalScrollBarVisibility == Visibility.Visible
+                        || scrollViewer.ComputedHorizontalScrollBarVisibility == Visibility.Visible;
+            }
+            if (checkFlowDoc)
+            {
+                var flowDocument = element.FindAncestor<FlowDocument>();
+                if (flowDocument != null)
+                {
+                    return true;
+                }
+            }
+
+            return false;
+        }
+
+        private static double CoercePanTranslate(double oldTranslate, double mousePos, double oldZoom, double newZoom)
+        {
+            return Math.Round(oldTranslate + (oldTranslate - mousePos) * (newZoom - oldZoom) / oldZoom);
+        }
+
+        protected override void OnMouseUp(MouseButtonEventArgs e)
+        {
+            base.OnMouseUp(e);
+
+            if (e.MiddleButton == MouseButtonState.Released)
+            {
+                _panPoint = null;
+                ReleaseMouseCapture();
+            }
+        }
+        protected override void OnPreviewMouseMove(MouseEventArgs e)
+        {
+            base.OnPreviewMouseMove(e);
+            if (e.MiddleButton == MouseButtonState.Pressed && _panPoint.HasValue)
+            {
+                //PAN MODE
+                var vector = e.GetPosition(this) - _panPoint.Value;
+                _panPoint = _panPoint + vector;
+                CaptureMouse();
+                TranslateX += vector.X;
+                TranslateY += vector.Y;
+                BeginAnimation(TranslateXProperty, null);
+                BeginAnimation(TranslateYProperty, null);
+            }
+        }
+
+    }
+}