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 static void RemoveListener(Viewport2D vp, IWeakEventListener listener)
{
ExtendedPropertyChangedEventManager.CurrentManager.ProtectedRemoveListener(vp, listener);
}
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);
}
void ISupportAttachToViewport.Detach(Viewport2D viewport)
{
((INotifyCollectionChanged)viewport.ContentBoundsHosts).CollectionChanged -= OnContentBoundsHostsChanged;
}
