public override Rect Apply(Rect oldDataRect, Rect newDataRect, Viewport2D viewport) { if (newDataRect.Width < minSize || newDataRect.Height < minSize) return oldDataRect; return newDataRect; }
protected override void UpdateScrollBar(Viewport2D viewport) { if (viewport != null && !viewport.Domain.IsEmpty) { if (ScrollBar.Track != null) { //ScrollBar.Track.IsDirectionReversed = true; } visibleRange = new Range<double>(viewport.Visible.YMin, viewport.Visible.YMax); domainRange = new Range<double>(viewport.Domain.YMin, viewport.Domain.YMax); double size = visibleRange.Max - visibleRange.Min; ScrollBar.ViewportSize = size; ScrollBar.Minimum = domainRange.Min + size; ScrollBar.Maximum = domainRange.Max; ScrollBar.Value = visibleRange.Min; ScrollBar.Visibility = Visibility.Visible; } else { ScrollBar.Visibility = Visibility.Collapsed; } }
/// <summary> /// Applies the restriction. /// </summary> /// <param name="previousDataRect">Previous data rectangle.</param> /// <param name="proposedDataRect">Proposed data rectangle.</param> /// <param name="viewport">The viewport, to which current restriction is being applied.</param> /// <returns>New changed visible rectangle.</returns> public override DataRect Apply(DataRect previousDataRect, DataRect proposedDataRect, Viewport2D viewport) { if (proposedDataRect.Width < minSize || proposedDataRect.Height < minSize) return previousDataRect; return proposedDataRect; }
/// <summary> /// Applies the specified old data rect. /// </summary> /// <param name="oldDataRect">The old data rect.</param> /// <param name="newDataRect">The new data rect.</param> /// <param name="viewport">The viewport.</param> /// <returns></returns> public override DataRect Apply(DataRect oldDataRect, DataRect newDataRect, Viewport2D viewport) { DataRect res = domain; if (domain.IsEmpty) { res = newDataRect; } else if (newDataRect.IntersectsWith(domain)) { res = newDataRect; if (newDataRect.Size == oldDataRect.Size) { if (res.XMin < domain.XMin) res.XMin = domain.XMin; if (res.YMin < domain.YMin) res.YMin = domain.YMin; if (res.XMax > domain.XMax) res.XMin += domain.XMax - res.XMax; if (res.YMax > domain.YMax) res.YMin += domain.YMax - res.YMax; } else { res = DataRect.Intersect(newDataRect, domain); } } return res; }
public ScaleInjectionConstraint(Viewport2D parentViewport) { if (parentViewport == null) throw new ArgumentNullException("parentViewport"); this.parentViewport = parentViewport; parentViewport.PropertyChanged += parentViewport_PropertyChanged; }
/// <summary> /// Applies the specified old data rect. /// </summary> /// <param name="oldDataRect">The old data rect.</param> /// <param name="newDataRect">The new data rect.</param> /// <param name="viewport">The viewport.</param> /// <returns></returns> public override DataRect Apply(DataRect oldDataRect, DataRect newDataRect, Viewport2D viewport) { bool decreasing = newDataRect.Width < oldDataRect.Width || newDataRect.Height < oldDataRect.Height; if (!decreasing && (newDataRect.Width > maxSize || newDataRect.Height > maxSize)) return oldDataRect; return newDataRect; }
public InjectionDelegateConstraint(Viewport2D masterViewport, ViewportConstraintCallback callback) { if (callback == null) throw new ArgumentNullException("callback"); if (masterViewport == null) throw new ArgumentNullException("masterViewport"); this.callback = callback; this.masterViewport = masterViewport; masterViewport.PropertyChanged += masterViewport_PropertyChanged; }
public override DataRect Apply(DataRect previousDataRect, DataRect proposedDataRect, Viewport2D viewport) { DataRect borderRect = DataRect.Create(minSeconds, proposedDataRect.YMin, maxSeconds, proposedDataRect.YMax); if (proposedDataRect.IntersectsWith(borderRect)) { DataRect croppedRect = DataRect.Intersect(proposedDataRect, borderRect); return croppedRect; } return previousDataRect; }
public override DataRect Apply(DataRect previousDataRect, DataRect proposedDataRect, Viewport2D viewport) { DataRect parentVisible = parentViewport.Visible; double xmin = parentVisible.XMin * xScale + xShift; double xmax = parentVisible.XMax * xScale + xShift; double ymin = parentVisible.YMin * yScale + yShift; double ymax = parentVisible.YMax * yScale + yShift; return DataRect.Create(xmin, ymin, xmax, ymax); }
/// <summary> /// Creates the environment. /// </summary> /// <param name="viewport">The viewport.</param> /// <returns></returns> public override DataSourceEnvironment CreateEnvironment(Viewport2D viewport) { DataSourceEnvironment result = new DataSourceEnvironment { Output = viewport.Output, Visible = viewport.Visible, RealVisible = viewport.Visible, Transform = viewport.Transform }; return result; }
public override DataRect Apply(DataRect oldDataRect, DataRect newDataRect, Viewport2D viewport) { double ratio = newDataRect.Width / newDataRect.Height; double coeff = Math.Sqrt(ratio); double newWidth = newDataRect.Width / coeff; double newHeight = newDataRect.Height * coeff; Point center = newDataRect.GetCenter(); DataRect res = DataRect.FromCenterSize(center, newWidth, newHeight); return res; }
/// <summary> /// Creates the environment. /// </summary> /// <param name="viewport">The viewport.</param> /// <returns></returns> public override DataSourceEnvironment CreateEnvironment(Viewport2D viewport) { Rect bigOutput = viewport.Output.ZoomOutFromCenter(enlargeFactor); DataRect bigVisible = viewport.Visible.ZoomOutFromCenter(enlargeFactor); CoordinateTransform transform = CoordinateTransform.FromRects(bigVisible, bigOutput); return new DataSourceEnvironment { Visible = bigVisible, RealVisible = viewport.Visible, Output = bigOutput, Transform = transform }; }
/// <summary> /// Applies the restriction. /// </summary> /// <param name="previousDataRect">Previous data rectangle.</param> /// <param name="proposedDataRect">Proposed data rectangle.</param> /// <param name="viewport">The viewport, to which current restriction is being applied.</param> /// <returns>New changed visible rectangle.</returns> public override DataRect Apply(DataRect previousDataRect, DataRect proposedDataRect, Viewport2D viewport) { if (proposedDataRect.IsEmpty) return proposedDataRect; double followWidth = proposedDataRect.Width; if (!viewport.UnitedContentBounds.IsEmpty) { followWidth = Math.Min(width, viewport.UnitedContentBounds.Width); } if (followWidth.IsInfinite()) followWidth = width; Rect visible = new Rect(proposedDataRect.XMin + proposedDataRect.Width - followWidth, proposedDataRect.YMin, followWidth, proposedDataRect.Height); return visible; }
public override Rect Apply(Rect oldDataRect, Rect newDataRect, Viewport2D viewport) { Rect res = oldDataRect; if (newDataRect.IntersectsWith(border)) { res = newDataRect; if (newDataRect.Size == oldDataRect.Size) { if (res.X < border.X) res.X = border.X; if (res.Y < border.Y) res.Y = border.Y; if (res.Right > border.Right) res.X += border.Right - res.Right; if (res.Bottom > border.Bottom) res.Y += border.Bottom - res.Bottom; } else { res = Rect.Intersect(newDataRect, border); } } return res; }
/// <summary> /// Applies the restriction. /// </summary> /// <param name="previousDataRect">Previous data rectangle.</param> /// <param name="proposedDataRect">Proposed data rectangle.</param> /// <param name="viewport">The viewport, to which current restriction is being applied.</param> /// <returns>New changed visible rectangle.</returns> public override DataRect Apply(DataRect previousDataRect, DataRect proposedDataRect, Viewport2D viewport) { Rect output = viewport.Output; if (output.Height == 0 || output.Width == 0) return proposedDataRect; double newRatio = proposedDataRect.Width * output.Height / (proposedDataRect.Height * output.Width); // Don't modify rect if new ratio differs only slightly if (Math.Abs(newRatio - proportionRatio) < 1e-3) return proposedDataRect; // Try to keep visible rect's square constant double width = proposedDataRect.Width, height = proposedDataRect.Height; double square = proposedDataRect.Width * proposedDataRect.Height; if (square > 0) { width = Math.Sqrt(proportionRatio * output.Width * square / output.Height); height = Math.Sqrt(output.Height * square / (proportionRatio * output.Width)); } // Finally ensure we have correct aspect ratio double delta = (proportionRatio * height * output.Width - width * output.Height) / (output.Height + proportionRatio * output.Width); width += delta; height -= delta; double x0 = (proposedDataRect.XMax + proposedDataRect.XMin) / 2; double y0 = (proposedDataRect.YMax + proposedDataRect.YMin) / 2; return new DataRect { XMin = x0 - width / 2, Width = width, YMin = y0 - height / 2, Height = height }; }
protected override void UpdateScrollBar(Viewport2D viewport) { if (viewport != null && !viewport.Domain.IsEmpty) { var visibleRange = new Range<double>(viewport.Visible.XMin, viewport.Visible.XMax); double size = visibleRange.Max - visibleRange.Min; ScrollBar.ViewportSize = size; var domainRange = new Range<double>(viewport.Domain.XMin, viewport.Domain.XMax); ScrollBar.Minimum = domainRange.Min; ScrollBar.Maximum = domainRange.Max - size; ScrollBar.Value = visibleRange.Min; ScrollBar.Visibility = Visibility.Visible; } else { ScrollBar.Visibility = Visibility.Collapsed; } }
public override Rect Apply(Rect oldDataRect, Rect newDataRect, Viewport2D viewport) { Rect output = viewport.Output; if (output.Width == 0 || output.Height == 0) return newDataRect; double screenRatio = output.Width / output.Height; double viewportRatio = newDataRect.Width / newDataRect.Height; double ratio = screenRatio / viewportRatio; double width = proportionRatio * newDataRect.Width * ratio; double height = newDataRect.Height; if (width < newDataRect.Width) { height = newDataRect.Height / proportionRatio / ratio; width = newDataRect.Width; } Point center = newDataRect.GetCenter(); Rect res = RectExtensions.FromCenterSize(center, width, height); return res; }
protected override void OnRender(DrawingContext drawingContext) { if (Plotter2D == null) { return; } if (Collection == null) { return; } if (DataSource == null) { return; } if (Collection.Lines.Count == 0) { IsolineBuilder.DataSource = DataSource; IsolineBuilder.MissingValue = MissingValue; Collection = IsolineBuilder.BuildIsoline(); } IsolineCollection = Collection; var dc = drawingContext; var strokeThickness = StrokeThickness; var collection = Collection; var bounds = DataRect.Empty; // determining content bounds foreach (LevelLine line in collection) { foreach (Point point in line.AllPoints) { bounds.Union(point); } } Viewport2D.SetContentBounds(this, bounds); ViewportPanel.SetViewportBounds(this, bounds); if (bounds.IsEmpty) { return; } // custom transform with output set to renderSize of this control var transform = Plotter2D.Transform.WithRects(bounds, new Rect(RenderSize)); // actual drawing of isolines RenderIsolineCollection(dc, strokeThickness, collection, transform); //var additionalLevels = GetAdditionalIsolines(collection); //var additionalIsolineCollections = additionalLevels.Select(level => IsolineBuilder.BuildIsoline(level)); //foreach (var additionalCollection in additionalIsolineCollections) //{ // RenderIsolineCollection(dc, strokeThickness, additionalCollection, transform); //} RenderLabels(dc, collection); // foreach (var additionalCollection in additionalIsolineCollections) // { // RenderLabels(dc, additionalCollection); // } }
public abstract Rect Apply(Rect oldDataRect, Rect newDataRect, Viewport2D viewport);
/// <summary> /// Creates the environment. /// </summary> /// <param name="viewport">The viewport.</param> /// <returns></returns> public abstract DataSourceEnvironment CreateEnvironment(Viewport2D viewport);
protected override void StopListening(object source) { Viewport2D vp = (Viewport2D)source; vp.PropertyChanged -= ViewportPropertyChanged; }
protected override void MouseDraggingToDraw(Viewport2D viewport, ViewportEvent e) { // }
public Camera2DViewportListener(Viewport2D viewport) { Viewport = viewport; Viewport2D = viewport; }
/// <summary> /// Applies the restriction. /// </summary> /// <param name="previousDataRect">Previous data rectangle.</param> /// <param name="proposedDataRect">Proposed data rectangle.</param> /// <param name="viewport">The viewport, to which current restriction is being applied.</param> /// <returns>New changed visible rectangle.</returns> public abstract DataRect Apply(DataRect previousDataRect, DataRect proposedDataRect, Viewport2D viewport);
protected virtual void LeftMouseClickOnResizeHandle(Viewport2D vp, ViewportEvent e) { State.Action = BoxAction.ReadyToResize; }
protected Tuple <Coordinate, Coordinate> GetResizedBoxCoordinates(Viewport2D viewport, ViewportEvent e) { if (State.Action != BoxAction.Resizing && State.Action != BoxAction.Drawing) { return(Tuple.Create(State.BoxStart, State.BoxEnd)); } var now = SnapIfNeeded(viewport.ScreenToWorld(e.X, viewport.Height - e.Y)); var cstart = viewport.Flatten(State.BoxStart); var cend = viewport.Flatten(State.BoxEnd); // Proportional scaling var ostart = viewport.Flatten(State.PreTransformBoxStart ?? Coordinate.Zero); var oend = viewport.Flatten(State.PreTransformBoxEnd ?? Coordinate.Zero); var owidth = oend.X - ostart.X; var oheight = oend.Y - ostart.Y; var proportional = KeyboardState.Ctrl && State.Action == BoxAction.Resizing && owidth != 0 && oheight != 0; switch (State.Handle) { case ResizeHandle.TopLeft: cstart.X = now.X; cend.Y = now.Y; break; case ResizeHandle.Top: cend.Y = now.Y; break; case ResizeHandle.TopRight: cend.X = now.X; cend.Y = now.Y; break; case ResizeHandle.Left: cstart.X = now.X; break; case ResizeHandle.Center: var cdiff = cend - cstart; cstart = viewport.Flatten(State.PreTransformBoxStart) + now - SnapIfNeeded(State.MoveStart); cend = cstart + cdiff; break; case ResizeHandle.Right: cend.X = now.X; break; case ResizeHandle.BottomLeft: cstart.X = now.X; cstart.Y = now.Y; break; case ResizeHandle.Bottom: cstart.Y = now.Y; break; case ResizeHandle.BottomRight: cend.X = now.X; cstart.Y = now.Y; break; default: throw new ArgumentOutOfRangeException(); } if (proportional) { var nwidth = cend.X - cstart.X; var nheight = cend.Y - cstart.Y; var mult = Math.Max(nwidth / owidth, nheight / oheight); var pwidth = owidth * mult; var pheight = oheight * mult; var wdiff = pwidth - nwidth; var hdiff = pheight - nheight; switch (State.Handle) { case ResizeHandle.TopLeft: cstart.X -= wdiff; cend.Y += hdiff; break; case ResizeHandle.TopRight: cend.X += wdiff; cend.Y += hdiff; break; case ResizeHandle.BottomLeft: cstart.X -= wdiff; cstart.Y -= hdiff; break; case ResizeHandle.BottomRight: cend.X += wdiff; cstart.Y -= hdiff; break; } } return(SnapBoxCoordinatesIfNeeded(viewport, cstart, cend)); }
public EqualXConstraint(Viewport2D other) { this.other = other; }
public Grid2DEventListener(Viewport2D viewport) { Viewport = viewport; Viewport2D = viewport; }
public override DataRect Apply(DataRect previousDataRect, DataRect proposedDataRect, Viewport2D viewport) { DataRect dataRect = proposedDataRect.WithY(other.Visible.YMin, other.Visible.YMax); if (dataRect != other.Visible) { other.Visible = dataRect; } return(proposedDataRect); }
public override DataRect Apply(DataRect previousDataRect, DataRect proposedDataRect, Viewport2D viewport) { DataRect parentVisible = parentViewport.Visible; double xmin = parentVisible.XMin * xScale + xShift; double xmax = parentVisible.XMax * xScale + xShift; double ymin = parentVisible.YMin * yScale + yShift; double ymax = parentVisible.YMax * yScale + yShift; return(DataRect.Create(xmin, ymin, xmax, ymax)); }
public TempIPlotterElement() { Viewport2D.SetIsContentBoundsHost(this, true); }
public void OnPlotterDetaching(Plotter plotter) { this.plotter.CentralGrid.Children.Remove(this); this.plotter = null; this.viewport.PropertyChanged -= OnViewportPropertyChanged; this.viewport = null; }
protected virtual bool ShouldRenderResizeBox(Viewport2D viewport) { return(State.ActiveViewport == viewport && (State.Action == BoxAction.ReadyToResize || State.Action == BoxAction.DownToResize)); }
private Tuple <Coordinate, Coordinate> GetBoxCoordinatesForSelectionResize(Viewport2D viewport, ViewportEvent e, BaseBoxTool.BoxState state, Document document) { if (state.Action != BaseBoxTool.BoxAction.Resizing) { return(Tuple.Create(state.BoxStart, state.BoxEnd)); } var now = SnapIfNeeded(viewport.ScreenToWorld(e.X, viewport.Height - e.Y), document); var cstart = viewport.Flatten(state.BoxStart); var cend = viewport.Flatten(state.BoxEnd); // Proportional scaling var ostart = viewport.Flatten(state.PreTransformBoxStart ?? Coordinate.Zero); var oend = viewport.Flatten(state.PreTransformBoxEnd ?? Coordinate.Zero); var owidth = oend.X - ostart.X; var oheight = oend.Y - ostart.Y; var proportional = KeyboardState.Ctrl && state.Action == BaseBoxTool.BoxAction.Resizing && owidth != 0 && oheight != 0; switch (state.Handle) { case BaseBoxTool.ResizeHandle.TopLeft: cstart.X = Math.Min(now.X, cend.X - 1); cend.Y = Math.Max(now.Y, cstart.Y + 1); break; case BaseBoxTool.ResizeHandle.Top: cend.Y = Math.Max(now.Y, cstart.Y + 1); break; case BaseBoxTool.ResizeHandle.TopRight: cend.X = Math.Max(now.X, cstart.X + 1); cend.Y = Math.Max(now.Y, cstart.Y + 1); break; case BaseBoxTool.ResizeHandle.Left: cstart.X = Math.Min(now.X, cend.X - 1); break; case BaseBoxTool.ResizeHandle.Center: var cdiff = cend - cstart; var distance = GetResizeDistance(viewport, e, state, document); if (distance == null) { cstart = viewport.Flatten(state.PreTransformBoxStart) + now - SnapIfNeeded(state.MoveStart, document); } else { cstart = viewport.Flatten(state.PreTransformBoxStart) + distance; } cend = cstart + cdiff; break; case BaseBoxTool.ResizeHandle.Right: cend.X = Math.Max(now.X, cstart.X + 1); break; case BaseBoxTool.ResizeHandle.BottomLeft: cstart.X = Math.Min(now.X, cend.X - 1); cstart.Y = Math.Min(now.Y, cend.Y - 1); break; case BaseBoxTool.ResizeHandle.Bottom: cstart.Y = Math.Min(now.Y, cend.Y - 1); break; case BaseBoxTool.ResizeHandle.BottomRight: cend.X = Math.Max(now.X, cstart.X + 1); cstart.Y = Math.Min(now.Y, cend.Y - 1); break; default: throw new ArgumentOutOfRangeException(); } if (proportional) { var nwidth = cend.X - cstart.X; var nheight = cend.Y - cstart.Y; var mult = Math.Max(nwidth / owidth, nheight / oheight); var pwidth = owidth * mult; var pheight = oheight * mult; var wdiff = pwidth - nwidth; var hdiff = pheight - nheight; switch (state.Handle) { case BaseBoxTool.ResizeHandle.TopLeft: cstart.X -= wdiff; cend.Y += hdiff; break; case BaseBoxTool.ResizeHandle.TopRight: cend.X += wdiff; cend.Y += hdiff; break; case BaseBoxTool.ResizeHandle.BottomLeft: cstart.X -= wdiff; cstart.Y -= hdiff; break; case BaseBoxTool.ResizeHandle.BottomRight: cend.X += wdiff; cstart.Y -= hdiff; break; } } cstart = viewport.Expand(cstart) + viewport.GetUnusedCoordinate(state.BoxStart); cend = viewport.Expand(cend) + viewport.GetUnusedCoordinate(state.BoxEnd); return(Tuple.Create(cstart, cend)); }
void ISupportAttachToViewport.Attach(Viewport2D viewport) { ((INotifyCollectionChanged)viewport.ContentBoundsHosts).CollectionChanged += OnContentBoundsHostsChanged; foreach (var item in viewport.ContentBoundsHosts) { PointsGraphBase chart = item as PointsGraphBase; if (chart != null) { chart.ProvideVisiblePoints = true; } } }
public override DataRect Apply(DataRect oldDataRect, DataRect newDataRect, Viewport2D viewport) { DataRect overallBounds = DataRect.Empty; foreach (var chart in viewport.ContentBoundsHosts) { var plotterElement = chart as IPlotterElement; //var visual = viewport.Plotter.VisualBindings[plotterElement]; var visual = plotterElement as DependencyObject; if (visual == null) { continue; } var points = (ReadOnlyCollection <Point>)PointsGraphBase.GetVisiblePoints(visual); if (points != null) { // searching for indices of chart's visible points which are near left and right borders of newDataRect double startX = newDataRect.XMin; double endX = newDataRect.XMax; if (points[0].X > endX || points[points.Count - 1].X < startX) { continue; } int startIndex = -1; // we assume that points are sorted by x values ascending if (startX <= points[0].X) { startIndex = 0; } else { for (int i = 1; i < points.Count - 1; i++) { if (points[i].X <= startX && startX < points[i + 1].X) { startIndex = i; break; } } } int endIndex = points.Count; if (points[points.Count - 1].X < endX) { endIndex = points.Count; } else { for (int i = points.Count - 1; i >= 1; i--) { if (points[i - 1].X <= endX && endX < points[i].X) { endIndex = i; break; } } } Rect bounds = Rect.Empty; for (int i = startIndex; i < endIndex; i++) { bounds.Union(points[i]); } if (startIndex > 0) { Point pt = GetInterpolatedPoint(startX, points[startIndex], points[startIndex - 1]); bounds.Union(pt); } if (endIndex < points.Count - 1) { Point pt = GetInterpolatedPoint(endX, points[endIndex], points[endIndex + 1]); bounds.Union(pt); } overallBounds.Union(bounds); } } if (!overallBounds.IsEmpty) { double y = overallBounds.YMin; double height = overallBounds.Height; if (height == 0) { height = newDataRect.Height; y -= height / 2; } newDataRect = new DataRect(newDataRect.XMin, y, newDataRect.Width, height); newDataRect = DataRectExtensions.ZoomY(newDataRect, newDataRect.GetCenter(), yEnlargeCoeff); } return(newDataRect); }
public override DataRect Apply(DataRect oldDataRect, DataRect newDataRect, Viewport2D viewport) { DataRect overallBounds = DataRect.Empty; foreach (var chart in viewport.ContentBoundsHosts) { var plotterElement = chart as IPlotterElement; var visual = viewport.Plotter.VisualBindings[plotterElement]; var points = (ReadOnlyCollection<Point>)PointsGraphBase.GetVisiblePoints(visual); if (points != null) { // searching for indices of chart's visible points which are near left and right borders of newDataRect double startX = newDataRect.XMin; double endX = newDataRect.XMax; if (points[0].X > endX || points[points.Count - 1].X < startX) { continue; } int startIndex = -1; // we assume that points are sorted by x values ascending if (startX <= points[0].X) { startIndex = 0; } else { for (int i = 1; i < points.Count - 1; i++) { if (points[i].X <= startX && startX < points[i + 1].X) { startIndex = i; break; } } } int endIndex = points.Count; if (points[points.Count - 1].X < endX) { endIndex = points.Count; } else { for (int i = points.Count - 1; i >= 1; i--) { if (points[i - 1].X <= endX && endX < points[i].X) { endIndex = i; break; } } } Rect bounds = Rect.Empty; for (int i = startIndex; i < endIndex; i++) { bounds.Union(points[i]); } if (startIndex > 0) { Point pt = GetInterpolatedPoint(startX, points[startIndex], points[startIndex - 1]); bounds.Union(pt); } if (endIndex < points.Count - 1) { Point pt = GetInterpolatedPoint(endX, points[endIndex], points[endIndex + 1]); bounds.Union(pt); } overallBounds.Union(bounds); } } if (!overallBounds.IsEmpty) { double y = overallBounds.YMin; double height = overallBounds.Height; if (height == 0) { height = newDataRect.Height; y -= height / 2; } newDataRect = new DataRect(newDataRect.XMin, y, newDataRect.Width, height); newDataRect = DataRectExtensions.ZoomY(newDataRect, newDataRect.GetCenter(), yEnlargeCoeff); } return newDataRect; }
protected override void LeftMouseDownToDraw(Viewport2D viewport, ViewportEvent e) { return; }
public static void RemoveListener(Viewport2D vp, IWeakEventListener listener) { ExtendedPropertyChangedEventManager.CurrentManager.ProtectedRemoveListener(vp, listener); }
void ISupportAttachToViewport.Detach(Viewport2D viewport) { ((INotifyCollectionChanged)viewport.ContentBoundsHosts).CollectionChanged -= OnContentBoundsHostsChanged; }
public override DataRect Apply(DataRect previousDataRect, DataRect proposedDataRect, Viewport2D viewport) { return(DataRect.Create(proposedDataRect.XMin, 0, proposedDataRect.XMax, 1)); }
protected override void LeftMouseUpDrawing(Viewport2D viewport, ViewportEvent e) { // }
public void BeforeRender2D(Viewport2D viewport) { throw new NotImplementedException(); }
private void Render2D(Viewport2D vp) { if (_state == ClipState.None || _clipPlanePoint1 == null || _clipPlanePoint2 == null || _clipPlanePoint3 == null) { return; // Nothing to draw at this point } var z = (double)vp.Zoom; var p1 = vp.Flatten(_clipPlanePoint1); var p2 = vp.Flatten(_clipPlanePoint2); var p3 = vp.Flatten(_clipPlanePoint3); // Draw points GL.Begin(BeginMode.Quads); GL.Color3(Color.White); GLX.Square(new Vector2d(p1.DX, p1.DY), 4, z, true); GLX.Square(new Vector2d(p2.DX, p2.DY), 4, z, true); GLX.Square(new Vector2d(p3.DX, p3.DY), 4, z, true); GL.End(); GL.Enable(EnableCap.LineSmooth); GL.Hint(HintTarget.LineSmoothHint, HintMode.Nicest); // Draw lines between points and point outlines GL.Begin(BeginMode.Lines); GL.Color3(Color.White); GL.Vertex2(p1.DX, p1.DY); GL.Vertex2(p2.DX, p2.DY); GL.Vertex2(p2.DX, p2.DY); GL.Vertex2(p3.DX, p3.DY); GL.Vertex2(p3.DX, p3.DY); GL.Vertex2(p1.DX, p1.DY); GL.Color3(Color.Black); GLX.Square(new Vector2d(p1.DX, p1.DY), 4, z); GLX.Square(new Vector2d(p2.DX, p2.DY), 4, z); GLX.Square(new Vector2d(p3.DX, p3.DY), 4, z); GL.End(); // Draw the clipped brushes if (!_clipPlanePoint1.EquivalentTo(_clipPlanePoint2) && !_clipPlanePoint2.EquivalentTo(_clipPlanePoint3) && !_clipPlanePoint1.EquivalentTo(_clipPlanePoint3)) { var plane = new Plane(_clipPlanePoint1, _clipPlanePoint2, _clipPlanePoint3); var faces = new List <Face>(); var idg = new IDGenerator(); foreach (var solid in Document.Selection.GetSelectedObjects().OfType <Solid>().ToList()) { Solid back, front; if (solid.Split(plane, out back, out front, idg)) { if (_side != ClipSide.Front) { faces.AddRange(back.Faces); } if (_side != ClipSide.Back) { faces.AddRange(front.Faces); } } } GL.LineWidth(2); GL.Color3(Color.White); Matrix.Push(); var mat = vp.GetModelViewMatrix(); GL.MultMatrix(ref mat); Rendering.Immediate.MapObjectRenderer.DrawWireframe(faces, true, false); Matrix.Pop(); GL.LineWidth(1); } GL.Hint(HintTarget.LineSmoothHint, HintMode.Fastest); GL.Disable(EnableCap.LineSmooth); }
public void Render2D(Viewport2D viewport, MapObject o) { throw new NotImplementedException(); }
public override void Render2D(Viewport2D viewport) { }
public override DataRect Apply(DataRect previousDataRect, DataRect proposedDataRect, Viewport2D viewport) { DataRect borderRect = DataRect.Create(minSeconds, proposedDataRect.YMin, maxSeconds, proposedDataRect.YMax); if (proposedDataRect.IntersectsWith(borderRect)) { DataRect croppedRect = DataRect.Intersect(proposedDataRect, borderRect); return(croppedRect); } return(previousDataRect); }
public override List <VMPoint> GetVerticesAtPoint(int x, int y, Viewport2D viewport) { return(new List <VMPoint>()); }
public void OnPlotterAttached(Plotter plotter) { this.plotter = (Plotter2D)plotter; if (this.plotter == null) throw new ArgumentException("Invalid plotter"); else { if (!dxInitialized) InitializeDX(); Initialize(); this.plotter.CentralGrid.Children.Add(this); this.viewport = this.plotter.Viewport; this.viewport.PropertyChanged += OnViewportPropertyChanged; } }
public override DataRect Apply(DataRect previousDataRect, DataRect proposedDataRect, Viewport2D viewport) { return callback(proposedDataRect); }
private void UpdateContentBounds(DependencyObject source) { var contentBounds = Viewport2D.GetContentBounds(source); Viewport2D.SetContentBounds(this, contentBounds); }
protected override void LeftMouseUpResizing(Viewport2D viewport, ViewportEvent e) { Document.Map.CordonBounds = new Box(State.BoxStart, State.BoxEnd); base.LeftMouseUpResizing(viewport, e); }
/// <summary> /// Applies the restriction. /// </summary> /// <param name="previousDataRect">Previous data rectangle.</param> /// <param name="proposedDataRect">Proposed data rectangle.</param> /// <param name="viewport">The viewport, to which current restriction is being applied.</param> /// <returns>New changed visible rectangle.</returns> public override DataRect Apply(DataRect previousDataRect, DataRect proposedDataRect, Viewport2D viewport) { if (proposedDataRect.IsEmpty) { return(proposedDataRect); } double followWidth = proposedDataRect.Width; if (!viewport.UnitedContentBounds.IsEmpty) { followWidth = Math.Min(width, viewport.UnitedContentBounds.Width); } if (followWidth.IsInfinite()) { followWidth = width; } Rect visible = new Rect(proposedDataRect.XMin + proposedDataRect.Width - followWidth, proposedDataRect.YMin, followWidth, proposedDataRect.Height); return(visible); }
protected override void LeftMouseClick(Viewport2D viewport, ViewportEvent e) { // }
protected override void LeftMouseClick(Viewport2D viewport, ViewportEvent e) { base.LeftMouseClick(viewport, e); }