Version 4.7.0: Added UWP Vector class

MapControl/UWP/Map.UWP.cs

@@ -17,7 +17,7 @@ namespace MapControl
             nameof(MouseWheelZoomDelta), typeof(double), typeof(Map), new PropertyMetadata(1d));
 
         private bool transformPending;
-        private Point transformTranslation;
+        private Vector transformTranslation;
         private double transformRotation;
         private double transformScale = 1d;
 

MapControl/UWP/MapControl.UWP.csproj

@@ -159,6 +159,7 @@
     <Compile Include="Tile.UWP.cs" />
     <Compile Include="TileImageLoader.UWP.cs" />
     <Compile Include="ImageLoader.UWP.cs" />
+    <Compile Include="Vector.UWP.cs" />
     <EmbeddedResource Include="Properties\MapControl.UWP.rd.xml" />
   </ItemGroup>
   <ItemGroup>

MapControl/UWP/Matrix.UWP.cs

@@ -41,16 +41,6 @@ namespace MapControl
             OffsetY += y;
         }
 
-        public void Scale(double scaleX, double scaleY)
-        {
-            if (M12 != 0d || M21 != 0d)
-            {
-                throw new NotSupportedException("Scale not supported for rotated Matrix");
-            }
-
-            SetMatrix(scaleX * M11, 0d, 0d, scaleY * M22, scaleX * OffsetX, scaleY * OffsetY);
-        }
-
         public void Rotate(double angle)
         {
             angle = (angle % 360d) / 180d * Math.PI;
@@ -80,10 +70,7 @@ namespace MapControl
             }
 
             SetMatrix(
-                invDet * M22,
-                invDet * -M12,
-                invDet * -M21,
-                invDet * M11,
+                invDet * M22, invDet * -M12, invDet * -M21, invDet * M11,
                 invDet * (M21 * OffsetY - M22 * OffsetX),
                 invDet * (M12 * OffsetX - M11 * OffsetY));
         }

MapControl/UWP/Point.UWP.cs

@@ -15,14 +15,39 @@ namespace MapControl
             Y = y;
         }
 
+        public static implicit operator Windows.Foundation.Point(Point p)
+        {
+            return new Windows.Foundation.Point(p.X, p.Y);
+        }
+
         public static implicit operator Point(Windows.Foundation.Point p)
         {
             return new Point(p.X, p.Y);
         }
 
-        public static implicit operator Windows.Foundation.Point(Point p)
+        public static explicit operator Point(Vector v)
         {
-            return new Windows.Foundation.Point(p.X, p.Y);
+            return new Point(v.X, v.Y);
+        }
+
+        public static Point operator -(Point p)
+        {
+            return new Point(-p.X, -p.Y);
+        }
+
+        public static Point operator +(Point p, Vector v)
+        {
+            return new Point(p.X + v.X, p.Y + v.Y);
+        }
+
+        public static Point operator -(Point p, Vector v)
+        {
+            return new Point(p.X - v.X, p.Y - v.Y);
+        }
+
+        public static Vector operator -(Point p1, Point p2)
+        {
+            return new Vector(p1.X - p2.X, p1.Y - p2.Y);
         }
 
         public static bool operator ==(Point p1, Point p2)

MapControl/UWP/Properties/AssemblyInfo.cs

@@ -7,8 +7,8 @@ using System.Runtime.InteropServices;
 [assembly: AssemblyCompany("Clemens Fischer")]
 [assembly: AssemblyCopyright("© 2018 Clemens Fischer")]
 [assembly: AssemblyTrademark("")]
-[assembly: AssemblyVersion("4.6.1")]
-[assembly: AssemblyFileVersion("4.6.1")]
+[assembly: AssemblyVersion("4.7.0")]
+[assembly: AssemblyFileVersion("4.7.0")]
 [assembly: AssemblyConfiguration("")]
 [assembly: AssemblyCulture("")]
 [assembly: ComVisible(false)]

MapControl/UWP/Vector.UWP.cs

@@ -0,0 +1,73 @@
+// XAML Map Control - https://github.com/ClemensFischer/XAML-Map-Control
+// © 2018 Clemens Fischer
+// Licensed under the Microsoft Public License (Ms-PL)
+
+namespace MapControl
+{
+    public struct Vector
+    {
+        public double X { get; set; }
+        public double Y { get; set; }
+
+        public Vector(double x, double y)
+        {
+            X = x;
+            Y = y;
+        }
+
+        public static implicit operator Windows.Foundation.Point(Vector v)
+        {
+            return new Windows.Foundation.Point(v.X, v.Y);
+        }
+
+        public static implicit operator Vector(Windows.Foundation.Point v)
+        {
+            return new Vector(v.X, v.Y);
+        }
+
+        public static explicit operator Vector(Point p)
+        {
+            return new Vector(p.X, p.Y);
+        }
+
+        public static Vector operator -(Vector v)
+        {
+            return new Vector(-v.X, -v.Y);
+        }
+
+        public static Point operator +(Vector v, Point p)
+        {
+            return new Point(v.X + p.X, v.Y + p.Y);
+        }
+
+        public static Vector operator +(Vector v1, Vector v2)
+        {
+            return new Vector(v1.X + v2.X, v1.Y + v2.Y);
+        }
+
+        public static Vector operator -(Vector v1, Vector v2)
+        {
+            return new Vector(v1.X - v2.X, v1.Y - v2.Y);
+        }
+
+        public static bool operator ==(Vector v1, Vector v2)
+        {
+            return v1.X == v2.X && v1.Y == v2.Y;
+        }
+
+        public static bool operator !=(Vector v1, Vector v2)
+        {
+            return !(v1 == v2);
+        }
+
+        public override bool Equals(object o)
+        {
+            return o is Vector && this == (Vector)o;
+        }
+
+        public override int GetHashCode()
+        {
+            return X.GetHashCode() ^ Y.GetHashCode();
+        }
+    }
+}