Exemple #1
0
 public static Rect ZoomInToCenter(this Rect rect, double ratio)
 {
     return(CoordinateUtilities.RectZoom(rect, rect.GetCenter(), 1 / ratio));
 }
Exemple #2
0
        protected virtual DataRect CoerceVisible(DataRect newVisible)
        {
            if (Plotter == null)
            {
                return(newVisible);
            }

            bool isDefaultValue = newVisible == (DataRect)VisibleProperty.DefaultMetadata.DefaultValue;

            if (isDefaultValue)
            {
                newVisible = DataRect.Empty;
            }

            if (isDefaultValue && IsFittedToView)
            {
                // determining content bounds
                DataRect bounds = DataRect.Empty;

                foreach (var item in contentBoundsHosts)
                {
                    IPlotterElement plotterElement = item as IPlotterElement;
                    if (plotterElement == null)
                    {
                        continue;
                    }
                    if (plotterElement.Plotter == null)
                    {
                        continue;
                    }

                    var plotter = (Plotter2D)plotterElement.Plotter;
                    var visual  = plotter.VisualBindings[plotterElement];
                    if (visual.Visibility == Visibility.Visible)
                    {
                        DataRect contentBounds = Viewport2D.GetContentBounds(item);
                        if (contentBounds.Width.IsNaN() || contentBounds.Height.IsNaN())
                        {
                            continue;
                        }

                        bounds.UnionFinite(contentBounds);
                    }
                }

                if (useApproximateContentBoundsComparison)
                {
                    var intersection = prevContentBounds;
                    intersection.Intersect(bounds);

                    double currSquare         = bounds.GetSquare();
                    double prevSquare         = prevContentBounds.GetSquare();
                    double intersectionSquare = intersection.GetSquare();

                    double squareTopLimit    = 1 + maxContentBoundsComparisonMistake;
                    double squareBottomLimit = 1 - maxContentBoundsComparisonMistake;

                    if (intersectionSquare != 0)
                    {
                        double currRatio = currSquare / intersectionSquare;
                        double prevRatio = prevSquare / intersectionSquare;

                        if (squareBottomLimit < currRatio &&
                            currRatio < squareTopLimit &&
                            squareBottomLimit < prevRatio &&
                            prevRatio < squareTopLimit)
                        {
                            bounds = prevContentBounds;
                        }
                    }
                }

                prevContentBounds   = bounds;
                UnitedContentBounds = bounds;

                // applying fit-to-view restrictions
                bounds = fitToViewRestrictions.Apply(Visible, bounds, this);

                // enlarging
                if (!bounds.IsEmpty)
                {
                    bounds = CoordinateUtilities.RectZoom(bounds, bounds.GetCenter(), clipToBoundsEnlargeFactor);
                }
                else
                {
                    bounds = (DataRect)VisibleProperty.DefaultMetadata.DefaultValue;
                }
                newVisible.Union(bounds);
            }

            if (newVisible.IsEmpty)
            {
                newVisible = (DataRect)VisibleProperty.DefaultMetadata.DefaultValue;
            }
            else if (newVisible.Width == 0 || newVisible.Height == 0)
            {
                DataRect defRect = (DataRect)VisibleProperty.DefaultMetadata.DefaultValue;
                Size     size    = newVisible.Size;
                Point    loc     = newVisible.Location;

                if (newVisible.Width == 0)
                {
                    size.Width = defRect.Width;
                    loc.X     -= size.Width / 2;
                }
                if (newVisible.Height == 0)
                {
                    size.Height = defRect.Height;
                    loc.Y      -= size.Height / 2;
                }

                newVisible = new DataRect(loc, size);
            }

            // apply domain restriction
            newVisible = domainRestriction.Apply(Visible, newVisible, this);

            // apply other restrictions
            newVisible = restrictions.Apply(Visible, newVisible, this);

            // applying transform's data domain restriction
            if (!transform.DataTransform.DataDomain.IsEmpty)
            {
                var newDataRect = newVisible.ViewportToData(transform);
                newDataRect = DataRect.Intersect(newDataRect, transform.DataTransform.DataDomain);
                newVisible  = newDataRect.DataToViewport(transform);
            }

            if (newVisible.IsEmpty)
            {
                newVisible = new Rect(0, 0, 1, 1);
            }

            return(newVisible);
        }
Exemple #3
0
 public static Rect Zoom(this Rect rect, Point to, double ratio)
 {
     return(CoordinateUtilities.RectZoom(rect, to, ratio));
 }
Exemple #4
0
 public static DataRect ZoomOutFromCenter(this DataRect rect, double ratio)
 {
     return(CoordinateUtilities.RectZoom(rect, rect.GetCenter(), ratio));
 }