Ejemplo n.º 1
0
		private 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)
				{
					var visual = plotter.VisualBindings[item];
					if (visual.Visibility == Visibility.Visible)
					{
						DataRect contentBounds = (DataRect)visual.GetValue(Viewport2D.ContentBoundsProperty);
						bounds.UnionFinite(contentBounds);
					}
				}

				DataRect viewportBounds = bounds;
				ContentBounds = 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;
		}
Ejemplo n.º 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)
                {
                    if ((MaxWidth > 0 && bounds.Width > MaxWidth))//设置了最大宽度
                    {
                        //bounds.XMin = 0 ;
                        bounds.Width  = MaxWidth;
                        bounds.Height = (MaxHeight >= 0 && bounds.Height > MaxHeight) ? MaxHeight : bounds.Height;
                        bounds        = bounds.DataToViewport(transform);
                    }
                    //else 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);
        }