/// <summary>
        /// Construct a TransformedBitmap with the given newTransform
        /// </summary>
        /// <param name="source">BitmapSource to apply to the newTransform to</param>
        /// <param name="newTransform">Transform to apply to the bitmap</param>
        public TransformedBitmap(BitmapSource source, Transform newTransform)
            : base(true) // Use base class virtuals
        {
            if (source == null)
            {
                throw new ArgumentNullException("source");
            }

            if (newTransform == null)
            {
                throw new InvalidOperationException(SR.Get(SRID.Image_NoArgument, "Transform"));
            }

            if (!CheckTransform(newTransform))
            {
                throw new InvalidOperationException(SR.Get(SRID.Image_OnlyOrthogonal));
            }

            _bitmapInit.BeginInit();

            Source = source;
            Transform = newTransform;

            _bitmapInit.EndInit();
            FinalizeCreation();
        }

		public EllipseGeometry (Point center, double radiusX, double radiusY, Transform transform)
		{
			Transform = transform;
			Center = center;
			RadiusX = radiusX;
			RadiusY = radiusY;
		}

        protected override void OnMouseMove(MouseEventArgs e)
        {
            Window wnd = Window.GetWindow(this);
            Point currentLocation = e.MouseDevice.GetPosition(wnd);

            var move = new TranslateTransform(
                currentLocation.X - _previousLocation.X, currentLocation.Y - _previousLocation.Y);

            if (e.LeftButton == MouseButtonState.Pressed)
            {
                var group = new TransformGroup();
                if (_previousTransform != null)
                {
                    group.Children.Add(_previousTransform);
                }
                group.Children.Add(move);

                RenderTransform = group;
            }
            else
            {
                Cursor = Cursors.Hand;
            }

            _previousLocation = currentLocation;
            _previousTransform = RenderTransform;

            MainWindow.Instance.CalculatePositions();
            base.OnMouseMove(e);
        }

 /// <summary>
 /// 
 /// </summary>
 public LineGeometry(
     Point startPoint,
     Point endPoint,
     Transform transform) : this(startPoint, endPoint)
 {
     Transform = transform;
 }

 public AdornerChartMarkers(UIElement adornedElement, Transform shapeTransform, IList<ChartMarkerSet> markerSets, XYLineChart parentChart) : base(adornedElement)
 {
     _adornedElement = adornedElement;
     _parentChart = parentChart;
     _markerSets = markerSets;
     _transform = shapeTransform;
 }

        internal override PathFigureCollection GetTransformedFigureCollection(Transform transform)
        {
            // Combine the transform argument with the internal transform
            Transform combined = new MatrixTransform(GetCombinedMatrix(transform));

            PathFigureCollection result = new PathFigureCollection();
            GeometryCollection children = Children;

            if (children != null)
            {
                for (int i = 0; i < children.Count; i++)
                {
                    PathFigureCollection pathFigures = children.Internal_GetItem(i).GetTransformedFigureCollection(combined);
                    if (pathFigures != null)
                    {
                        int count = pathFigures.Count;
                        for (int j = 0; j < count; ++j)
                        {
                            result.Add(pathFigures[j]);
                        }
                    }
                }
            }

            return result;
        }

		public RectangleGeometry (Rect rect, double radiusX, double radiusY, Transform transform)
		{
			Transform = transform;
			Rect = rect;
			RadiusX = radiusX;
			RadiusY = radiusY;
		}

 /// <summary>
 /// Constructor - sets the ellipse to the parameters 
 /// </summary>
 public EllipseGeometry(
     Point center,
     double radiusX, 
     double radiusY,
     Transform transform) : this(center, radiusX, radiusY) 
 { 
     Transform = transform;
 } 

 /// <summary>
 /// 
 /// </summary>
 /// <param name="rect"></param>
 /// <param name="radiusX"></param>
 /// <param name="radiusY"></param>
 /// <param name="transform"></param>
 public RectangleGeometry(
     Rect rect,
     double radiusX,
     double radiusY,
     Transform transform) : this(rect, radiusX, radiusY)
 {
     Transform = transform;
 }

 public static IEnumerable<Geometry> GetTransformedGeometries(IEnumerable<SqlGeometry> collection, Transform transform)
 {
     foreach (var item in collection)
     {
         Geometry wpf = item.ToWpfGeometry();
         wpf.Transform = transform;
          
         yield return wpf;
     }
 }

 /// <summary>
 /// Initializes a new instance of the LayoutTransformerScenario class.
 /// </summary>
 /// <param name="preferredWidth">Preferred width of the test control.</param>
 /// <param name="preferredHeight">Preferred height of the test control.</param>
 /// <param name="measureAtPreferredSize">Whether the child control should force its preferred size during Measure.</param>
 /// <param name="arrangeAtPreferredSize">Whether the child control should force its preferred size during Arrange.</param>
 /// <param name="measureWidth">Width to pass to Measure.</param>
 /// <param name="measureHeight">Height to pass to Measure.</param>
 /// <param name="desiredWidth">Expected DesiredSize.Width.</param>
 /// <param name="desiredHeight">Expected DesiredSize.Height.</param>
 /// <param name="arrangeWidth">Width to pass to Arrange.</param>
 /// <param name="arrangeHeight">Height to pass to Arrange.</param>
 /// <param name="renderWidth">Expected RenderSize.Width.</param>
 /// <param name="renderHeight">Expected RenderSize.Height.</param>
 /// <param name="transform">Transform to use.</param>
 public LayoutTransformerScenario(double preferredWidth, double preferredHeight, bool measureAtPreferredSize, bool arrangeAtPreferredSize, double measureWidth, double measureHeight, double desiredWidth, double desiredHeight, double arrangeWidth, double arrangeHeight, double renderWidth, double renderHeight, Transform transform)
 {
     PreferredSize = new Size(preferredWidth, preferredHeight);
     _measureAtPreferredSize = measureAtPreferredSize;
     _arrangeAtPreferredSize = arrangeAtPreferredSize;
     MeasureSize = new Size(measureWidth, measureHeight);
     DesiredSize = new Size(desiredWidth, desiredHeight);
     ArrangeSize = new Size(arrangeWidth, arrangeHeight);
     RenderSize = new Size(renderWidth, renderHeight);
     Transform = transform;
 }

 public void RenderUnfilledElements(DrawingContext ctx, Rect chartArea, Transform transform) {
   CalculateGeometry(chartArea);
   if(LineColor != Colors.Transparent && LineThickness > 0) {
     Pen pen = new Pen(new SolidColorBrush(LineColor), LineThickness);
     pen.LineJoin = PenLineJoin.Bevel;
     if(IsDashed) {
       pen.DashStyle = new DashStyle(new double[] { 2, 2 }, 0);
     }
     _unfilledGeometry.Transform = transform;
     ctx.DrawGeometry(null, pen, _unfilledGeometry);
   }
 }

        public static void StartAnimation (Transform animatableElement, DependencyProperty dependencyProperty, double toValue, double durationMilliseconds, double accelerationRatio, double decelerationRatio)
        {
            DoubleAnimation animation = new DoubleAnimation();
            animation.To = toValue;
            animation.AccelerationRatio = accelerationRatio;
            animation.DecelerationRatio = decelerationRatio;
            animation.FillBehavior = FillBehavior.HoldEnd;
            animation.Duration = TimeSpan.FromMilliseconds(durationMilliseconds);
            animation.Freeze();

            animatableElement.BeginAnimation(dependencyProperty, animation, HandoffBehavior.Compose);
        }

 /// <summary>
 /// Initializes a new instance of the <see cref="DoubleAnimator"/> class.
 /// </summary>
 /// <param name="translateTransform">The translate transform.</param>
 /// <param name="property">The property.</param>
 public DoubleAnimator(Transform transform, string property)
 {
     this.transform = transform;
     this.storyboard.Completed += this.OnCompleted;
     this.storyboard.Children.Add(this.animation);
     Storyboard.SetTarget(this.animation, this.transform);
     #if WINDOWS_PHONE
     Storyboard.SetTargetProperty(this.animation, new PropertyPath(property));
     #else
     Storyboard.SetTargetProperty(this.animation, property);
     #endif
 }

    public void RenderUnfilledElements(DrawingContext ctx, Rect chartArea, Transform transform) {

      for(int segmentIndex = 0; segmentIndex < _lineColors.Count; ++segmentIndex) {
        SolidColorBrush brush = new SolidColorBrush(_lineColors[segmentIndex]);
        Pen pen = new Pen(brush, LineThickness);
        pen.LineJoin = PenLineJoin.Bevel;
        if(IsDashed) {
          pen.DashStyle = new DashStyle(new double[] { 2, 2 }, 0);
        }
        ctx.DrawLine(pen, transform.Transform(Points[segmentIndex*2]), transform.Transform(Points[segmentIndex*2+1]));
      }
    }

        public override void Setup(VisualBrush prevBrush, VisualBrush nextBrush)
        {
            //store the visual that will be moved to view, so that if any changes are done to it we can rollback to the original state
            elementToMoveToView = (FrameworkElement)nextBrush.Visual;
            elementToMoveToViewTransform = elementToMoveToView.RenderTransform;
            elementToMovePoint = elementToMoveToView.RenderTransformOrigin;

            Owner.AddTransitionElement(_viewport);

            RegisterNameScope();

            AdjustViewport(Owner, prevBrush, nextBrush);
        }

 /// <summary>
 /// Gets the UIElement that can be added to the plot
 /// </summary>
 /// <returns></returns>
 public void RenderFilledElements(DrawingContext ctx, Rect chartArea, Transform transform) {
   CalculateGeometry();
   int colorIndex = 0;
   foreach(var childGeometry in _filledGeometry.Children) {
     Color fillColor = _colors[colorIndex].Item2;
     if(fillColor != Colors.Transparent) {
       Brush brush = IsDashed ? (Brush)(ChartUtilities.CreateHatch50(fillColor, new Size(2, 2))) : (Brush)(new SolidColorBrush(fillColor));
       childGeometry.Transform = transform;
       ctx.DrawGeometry(brush, null, childGeometry);
     }
     ++colorIndex;
   }
 }

        internal PathStreamGeometryContext(FillRule fillRule, 
                                           Transform transform)
        { 
            _pathGeometry = new PathGeometry(); 

            if (fillRule != s_defaultFillRule) 
            {
                _pathGeometry.FillRule = fillRule;
            }
 
            if ((transform != null) && !transform.IsIdentity)
            { 
                _pathGeometry.Transform = transform.Clone(); 
            }
        } 

        public RelativeLocationBinding(FrameworkElement item, IObservable<Transform> transforms, IObservable<Point?> locations = null)
        {
            if (item == null)
                throw new ArgumentNullException("item");
            if (transforms == null)
                throw new ArgumentNullException("transforms");

            this.item = item;
            item.Visibility = Visibility.Collapsed;

            subscription.Add(transforms.Subscribe(t => Transform = t));

            if (locations != null)
                this.subscription.Add(locations.Subscribe(loc => RelativeLocation = loc));
        }

partial         static void ScaleRect(ref Rect rect, ref Transform transform)
        {
            // Scales the RectangleGeometry to compensate inaccurate hit testing in WPF.
            // See http://stackoverflow.com/a/19335624/1136211

            rect.Scale(1e6, 1e6);

            var scaleTransform = new ScaleTransform(1e-6, 1e-6); // reverts rect scaling
            scaleTransform.Freeze();

            var transformGroup = new TransformGroup();
            transformGroup.Children.Add(scaleTransform);
            transformGroup.Children.Add(transform);

            transform = transformGroup;
        }