Link zoom and moveviewport tools

PixiEditor/Helpers/Converters/IsSpecifiedTypeConverter.cs

@@ -0,0 +1,21 @@
+using System;
+using System.Globalization;
+using System.Windows.Data;
+
+namespace PixiEditor.Helpers.Converters
+{
+    [ValueConversion(typeof(object), typeof(bool))]
+    public class IsSpecifiedTypeConverter : IValueConverter
+    {
+        public Type SpecifiedType { get; set; }
+        public object Convert(object value, Type targetType, object parameter, CultureInfo culture)
+        {
+            return value != null && value.GetType() == SpecifiedType;
+        }
+
+        public object ConvertBack(object value, Type targetType, object parameter, CultureInfo culture)
+        {
+            throw new NotImplementedException();
+        }
+    }
+}

PixiEditor/Views/MainWindow.xaml

@@ -4,6 +4,7 @@
         xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
         xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
         xmlns:local="clr-namespace:PixiEditor"
+        xmlns:tools="clr-namespace:PixiEditor.Models.Tools.Tools"
         xmlns:vm="clr-namespace:PixiEditor.ViewModels"
         xmlns:vws="clr-namespace:PixiEditor.Views"
         xmlns:converters="clr-namespace:PixiEditor.Helpers.Converters"
@@ -29,6 +30,8 @@
             <converters:NotNullToBoolConverter x:Key="NotNullToBoolConverter" />
             <converters:FloatNormalizeConverter x:Key="FloatNormalizeConverter" />
             <converters:DoubleToIntConverter x:Key="DoubleToIntConverter"/>
+            <converters:IsSpecifiedTypeConverter SpecifiedType="{x:Type tools:ZoomTool}" x:Key="IsZoomToolConverter"/>
+            <converters:IsSpecifiedTypeConverter SpecifiedType="{x:Type tools:MoveViewportTool}" x:Key="IsMoveViewportToolConverter"/>
             <ResourceDictionary.MergedDictionaries>
                 <ResourceDictionary Source="pack://application:,,,/ColorPicker;component/Styles/DefaultColorPickerStyle.xaml" />
             </ResourceDictionary.MergedDictionaries>
@@ -234,6 +237,8 @@
                                         MouseDownCommand="{Binding XamlAccesibleViewModel.IoSubViewModel.MouseDownCommand}"
                                         MouseXOnCanvas="{Binding MouseXOnCanvas, Mode=TwoWay}"
                                         MouseYOnCanvas="{Binding MouseYOnCanvas, Mode=TwoWay}"
+                                        IsUsingZoomTool="{Binding XamlAccesibleViewModel.BitmapManager.SelectedTool, Converter={StaticResource IsZoomToolConverter}}"
+                                        IsUsingMoveViewportTool="{Binding XamlAccesibleViewModel.BitmapManager.SelectedTool, Converter={StaticResource IsMoveViewportToolConverter}}"
                                         Stylus.IsTapFeedbackEnabled="False" Stylus.IsTouchFeedbackEnabled="False">
                                         <i:Interaction.Triggers>
                                             <i:EventTrigger EventName="PreviewMouseDown">

PixiEditor/Views/UserControls/DrawingViewPort.xaml

@@ -15,13 +15,18 @@
         <BooleanToVisibilityConverter x:Key="BoolToVisibilityConverter" />
         <converters:IntToViewportRectConverter x:Key="IntToViewportRectConverter" />
     </UserControl.Resources>
-    <vws:MainDrawingPanel x:Name="DrawingPanel">
+    <vws:MainDrawingPanel x:Name="DrawingPanel"
+                          IsUsingMoveViewportTool="{Binding IsUsingMoveViewportTool, ElementName=uc}"
+                          IsUsingZoomTool="{Binding IsUsingZoomTool, ElementName=uc}">
         <i:Interaction.Triggers>
             <i:EventTrigger EventName="MouseMove">
                 <i:InvokeCommandAction Command="{Binding MouseMoveCommand, ElementName=uc}" />
             </i:EventTrigger>
             <i:EventTrigger EventName="MouseDown">
-                <i:InvokeCommandAction Command="{Binding InternalMouseDownCommand, ElementName=uc}"/>
+                <i:InvokeCommandAction Command="{Binding MouseDownCommand, ElementName=uc}"/>
+            </i:EventTrigger>
+            <i:EventTrigger EventName="PreviewMouseDown">
+                <i:InvokeCommandAction Command="{Binding PreviewMouseDownCommand, ElementName=uc}"/>
             </i:EventTrigger>
         </i:Interaction.Triggers>
         <i:Interaction.Behaviors>

PixiEditor/Views/UserControls/DrawingViewPort.xaml.cs

@@ -29,6 +29,12 @@ namespace PixiEditor.Views.UserControls
         public static readonly DependencyProperty GridLinesVisibleProperty =
             DependencyProperty.Register(nameof(GridLinesVisible), typeof(bool), typeof(DrawingViewPort), new PropertyMetadata(false));
 
+        public static readonly DependencyProperty IsUsingZoomToolProperty =
+            DependencyProperty.Register(nameof(IsUsingZoomTool), typeof(bool), typeof(DrawingViewPort), new PropertyMetadata(false));
+
+        public static readonly DependencyProperty IsUsingMoveViewportToolProperty =
+            DependencyProperty.Register(nameof(IsUsingMoveViewportTool), typeof(bool), typeof(DrawingViewPort), new PropertyMetadata(false));
+
         public ICommand MiddleMouseClickedCommand
         {
             get => (ICommand)GetValue(MiddleMouseClickedCommandProperty);
@@ -64,12 +70,22 @@ namespace PixiEditor.Views.UserControls
             get => (bool)GetValue(GridLinesVisibleProperty);
             set => SetValue(GridLinesVisibleProperty, value);
         }
+        public bool IsUsingZoomTool
+        {
+            get => (bool)GetValue(IsUsingZoomToolProperty);
+            set => SetValue(IsUsingZoomToolProperty, value);
+        }
+        public bool IsUsingMoveViewportTool
+        {
+            get => (bool)GetValue(IsUsingMoveViewportToolProperty);
+            set => SetValue(IsUsingMoveViewportToolProperty, value);
+        }
 
-        public RelayCommand InternalMouseDownCommand { get; private set; }
+        public RelayCommand PreviewMouseDownCommand { get; private set; }
 
         public DrawingViewPort()
         {
-            InternalMouseDownCommand = new RelayCommand(ProcessMouseDown);
+            PreviewMouseDownCommand = new RelayCommand(ProcessMouseDown);
             InitializeComponent();
         }
 
@@ -77,8 +93,6 @@ namespace PixiEditor.Views.UserControls
         {
             if (Mouse.MiddleButton == MouseButtonState.Pressed && MiddleMouseClickedCommand.CanExecute(typeof(MoveViewportTool)))
                 MiddleMouseClickedCommand.Execute(typeof(MoveViewportTool));
-            if (MouseDownCommand.CanExecute(null))
-                MouseDownCommand.Execute(null);
         }
     }
 }

PixiEditor/Views/UserControls/MainDrawingPanel.xaml

@@ -8,18 +8,13 @@
              xmlns:i="clr-namespace:System.Windows.Interactivity;assembly=System.Windows.Interactivity"
              xmlns:helpers="clr-namespace:PixiEditor.Helpers"
              xmlns:xctk="http://schemas.xceed.com/wpf/xaml/toolkit"
-             mc:Ignorable="d" PreviewMouseDown="MainDrawingPanel_PreviewMouseDown" PreviewMouseUp="MainDrawingPanel_PreviewMouseUp"
+             mc:Ignorable="d"
              d:DesignHeight="450" d:DesignWidth="800" x:Name="mainDrawingPanel">
     <Grid>
-        <userc:Zoombox AdditionalContent="{Binding Item, ElementName=mainDrawingPanel}" />
-        <xctk:Zoombox Cursor="{Binding Cursor}" Name="Zoombox" KeepContentInBounds="False" Visibility="Hidden"
-                  IsAnimated="False"
-                  CurrentViewChanged="Zoombox_CurrentViewChanged" DragModifiers="Blocked" ZoomModifiers="None">
-            <i:Interaction.Triggers>
-                <i:EventTrigger EventName="MouseMove">
-                    <i:InvokeCommandAction Command="{Binding MouseMoveCommand, ElementName=mainDrawingPanel, Mode=OneWay}" />
-                </i:EventTrigger>
-            </i:Interaction.Triggers>
+        <userc:Zoombox AdditionalContent="{Binding Item, ElementName=mainDrawingPanel}" x:Name="zoombox" />
+        <xctk:Zoombox Cursor="{Binding Cursor, ElementName=mainDrawingPanel}" KeepContentInBounds="False" Visibility="Hidden"
+                  IsAnimated="False" DragModifiers="Blocked" ZoomModifiers="None">
+
         </xctk:Zoombox>
     </Grid>
 </UserControl>

PixiEditor/Views/UserControls/MainDrawingPanel.xaml.cs

@@ -1,48 +1,19 @@
-using PixiEditor.Models.Tools.Tools;
-using PixiEditor.ViewModels;
+using PixiEditor.Views.UserControls;
 using System.Windows;
 using System.Windows.Controls;
-using System.Windows.Input;
-using Xceed.Wpf.Toolkit.Core.Input;
-using Xceed.Wpf.Toolkit.Zoombox;
 
 namespace PixiEditor.Views
 {
     public partial class MainDrawingPanel : UserControl
     {
-        public static readonly DependencyProperty MouseXProperty =
-            DependencyProperty.Register(nameof(MouseX), typeof(double), typeof(MainDrawingPanel), new PropertyMetadata(null));
-
-        public static readonly DependencyProperty MouseYProperty =
-            DependencyProperty.Register(nameof(MouseY), typeof(double), typeof(MainDrawingPanel), new PropertyMetadata(null));
-
-        public static readonly DependencyProperty MouseMoveCommandProperty =
-            DependencyProperty.Register(nameof(MouseMoveCommand), typeof(ICommand), typeof(MainDrawingPanel),
-                new PropertyMetadata(null));
-
         public static readonly DependencyProperty ItemProperty =
             DependencyProperty.Register(nameof(Item), typeof(object), typeof(MainDrawingPanel), new PropertyMetadata(default(FrameworkElement)));
 
         public static readonly DependencyProperty IsUsingZoomToolProperty =
-            DependencyProperty.Register(nameof(IsUsingZoomTool), typeof(bool), typeof(MainDrawingPanel), new PropertyMetadata(false));
-
-        public double MouseX
-        {
-            get => (double)GetValue(MouseXProperty);
-            set => SetValue(MouseXProperty, value);
-        }
+            DependencyProperty.Register(nameof(IsUsingZoomTool), typeof(bool), typeof(MainDrawingPanel), new PropertyMetadata(false, ToolChanged));
 
-        public double MouseY
-        {
-            get => (double)GetValue(MouseYProperty);
-            set => SetValue(MouseYProperty, value);
-        }
-
-        public ICommand MouseMoveCommand
-        {
-            get => (ICommand)GetValue(MouseMoveCommandProperty);
-            set => SetValue(MouseMoveCommandProperty, value);
-        }
+        public static readonly DependencyProperty IsUsingMoveViewportToolProperty =
+            DependencyProperty.Register(nameof(IsUsingMoveViewportTool), typeof(bool), typeof(MainDrawingPanel), new PropertyMetadata(false, ToolChanged));
 
         public object Item
         {
@@ -55,30 +26,26 @@ namespace PixiEditor.Views
             get => (bool)GetValue(IsUsingZoomToolProperty);
             set => SetValue(IsUsingZoomToolProperty, value);
         }
-
-        public Point ClickPosition;
-
-        public MainDrawingPanel()
-        {
-            InitializeComponent();
-            Zoombox.ZoomToSelectionModifiers = new KeyModifierCollection() { KeyModifier.RightAlt };
-        }
-
-        private void MainDrawingPanel_PreviewMouseDown(object sender, MouseButtonEventArgs e)
+        public bool IsUsingMoveViewportTool
         {
-            IsUsingZoomTool = ViewModelMain.Current.BitmapManager.SelectedTool is ZoomTool;
-            Mouse.Capture((IInputElement)sender, CaptureMode.SubTree);
-            ClickPosition = ((FrameworkElement)Item).TranslatePoint(new Point(0, 0), Zoombox);
+            get => (bool)GetValue(IsUsingMoveViewportToolProperty);
+            set => SetValue(IsUsingMoveViewportToolProperty, value);
         }
 
-        private void MainDrawingPanel_PreviewMouseUp(object sender, MouseButtonEventArgs e)
+        public MainDrawingPanel()
         {
-            ((IInputElement)sender).ReleaseMouseCapture();
+            InitializeComponent();
         }
 
-        private void Zoombox_CurrentViewChanged(object sender, ZoomboxViewChangedEventArgs e)
+        private static void ToolChanged(DependencyObject sender, DependencyPropertyChangedEventArgs args)
         {
-            Zoombox.MinScale = 32 / ((FrameworkElement)Item).Width;
+            var panel = (MainDrawingPanel)sender;
+            if (panel.IsUsingZoomTool)
+                panel.zoombox.ZoomMode = Zoombox.Mode.ZoomTool;
+            else if (panel.IsUsingMoveViewportTool)
+                panel.zoombox.ZoomMode = Zoombox.Mode.MoveTool;
+            else
+                panel.zoombox.ZoomMode = Zoombox.Mode.Normal;
         }
     }
 }

PixiEditor/Views/UserControls/ZoomBox.xaml.cs

@@ -138,12 +138,15 @@ namespace PixiEditor.Views.UserControls
         private double Zoom => Math.Pow(1.1, zoomPower);
 
         private IDragOperation activeDragOperation = null;
+        private MouseButtonEventArgs activeMouseDownEventArgs = null;
+        private Point activeMouseDownPos;
 
         private static void ZoomModeChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
         {
             Zoombox sender = (Zoombox)d;
             sender.activeDragOperation?.Terminate();
             sender.activeDragOperation = null;
+            sender.activeMouseDownEventArgs = null;
         }
 
         public Zoombox()
@@ -151,6 +154,19 @@ namespace PixiEditor.Views.UserControls
             InitializeComponent();
         }
 
+        public void ZoomInto(Point mousePos, double delta)
+        {
+            var oldZoomboxMousePos = ToZoomboxSpace(mousePos);
+
+            ZoomPower += delta;
+
+            if (Math.Abs(ZoomPower) < 1) ZoomPower = 0;
+
+            var shiftedMousePos = ToScreenSpace(oldZoomboxMousePos);
+            var deltaMousePos = mousePos - shiftedMousePos;
+            SpaceOriginPos = SpaceOriginPos + deltaMousePos;
+        }
+
         private Point ToScreenSpace(Point p)
         {
             double zoom = Zoom;
@@ -170,6 +186,12 @@ namespace PixiEditor.Views.UserControls
         }
 
         private void OnMouseDown(object sender, MouseButtonEventArgs e)
+        {
+            activeMouseDownEventArgs = e;
+            activeMouseDownPos = e.GetPosition(mainCanvas);
+        }
+
+        private void InitiateDrag(MouseButtonEventArgs e)
         {
             if (ZoomMode == Mode.Normal)
                 return;
@@ -186,27 +208,34 @@ namespace PixiEditor.Views.UserControls
 
         private void OnMouseUp(object sender, MouseButtonEventArgs e)
         {
-            activeDragOperation?.Terminate();
-            activeDragOperation = null;
+            if (activeDragOperation != null)
+            {
+                activeDragOperation?.Terminate();
+                activeDragOperation = null;
+            }
+            else
+            {
+                if (ZoomMode == Mode.ZoomTool)
+                    ZoomInto(e.GetPosition(mainCanvas), Keyboard.IsKeyDown(Key.LeftAlt) ? -1 : 1);
+            }
+            activeMouseDownEventArgs = null;
         }
 
         private void OnMouseMove(object sender, MouseEventArgs e)
         {
+            if (activeDragOperation == null && activeMouseDownEventArgs != null)
+            {
+                var cur = e.GetPosition(mainCanvas);
+
+                if (Math.Abs(cur.X - activeMouseDownPos.X) > 3)
+                    InitiateDrag(activeMouseDownEventArgs);
+            }
             activeDragOperation?.Update(e);
         }
 
         private void OnScroll(object sender, MouseWheelEventArgs e)
         {
-            var oldMousePos = e.GetPosition(mainCanvas);
-            var oldZoomboxMousePos = ToZoomboxSpace(oldMousePos);
-
-            ZoomPower += e.Delta / 100;
-
-            if (Math.Abs(ZoomPower) < 1) ZoomPower = 0;
-
-            var shiftedMousePos = ToScreenSpace(oldZoomboxMousePos);
-            var deltaMousePos = oldMousePos - shiftedMousePos;
-            SpaceOriginPos = SpaceOriginPos + deltaMousePos;
+            ZoomInto(e.GetPosition(mainCanvas), e.Delta / 100);
         }
     }
 }