protected override void OnViewUnregistered(CanvasView canvasView)
{
SizeDouble canvasExtentPadding = canvasView.CanvasExtentPadding;
canvasView.CanvasExtentPadding = new SizeDouble(canvasExtentPadding.Width - 8.0, canvasExtentPadding.Height - 8.0);
base.OnViewUnregistered(canvasView);
}
protected override void OnRender(IDrawingContext dc, RectFloat clipRect, CanvasView canvasView)
{
PointDouble viewportCanvasOffset = canvasView.ViewportCanvasOffset;
Matrix3x2Double num2 = dc.Transform.Inverse * Matrix3x2Double.Translation(-viewportCanvasOffset.X, -viewportCanvasOffset.Y);
this.checkerboardTx.Matrix = num2;
SizeDouble canvasSize = base.Owner.CanvasSize;
RectDouble rect = new RectDouble(PointDouble.Zero, canvasSize);
using (dc.UseAntialiasMode(AntialiasMode.Aliased))
{
using (CastOrRefHolder <IDrawingContext1> holder = dc.TryCastOrCreateRef <IDrawingContext1>())
{
if (holder.HasRef)
{
using (holder.ObjectRef.UsePrimitiveBlend(PrimitiveBlend.Copy))
{
dc.FillRectangle(rect, this.checkerboardBitmapBrush);
goto Label_00CC;
}
}
dc.FillRectangle(rect, this.checkerboardBitmapBrush);
}
}
Label_00CC:
base.OnRender(dc, clipRect, canvasView);
}
protected override void OnRender(IDrawingContext dc, RectFloat clipRect, CanvasView canvasView)
{
if ((canvasView.ScaleRatio >= 2.0) && GetIsPixelGridEnabled(canvasView))
{
SizeDouble canvasSize = base.Owner.CanvasSize;
RectDouble b = new RectDouble(PointDouble.Zero, canvasSize);
RectInt32 rect = RectDouble.Intersect(clipRect, b).Int32Bound;
Matrix3x2Double transform = dc.Transform;
double num6 = 1.0 / canvasView.CanvasHairWidth;
RectDouble num7 = transform.Transform(rect);
double num9 = DoubleUtil.Clamp((canvasView.ScaleRatio - 2.0) / 4.0, 0.0, 1.0) / 2.0;
this.stippleBitmapBrush.Opacity = num9;
using (dc.UseAntialiasMode(AntialiasMode.Aliased))
{
using (dc.UseTransform(Matrix3x2Float.Identity))
{
using (dc.UseAxisAlignedClip((RectFloat)num7, AntialiasMode.Aliased))
{
for (int i = -(rect.Width & 1); i <= rect.Width; i++)
{
dc.DrawLine(num7.X + (i * num6), num7.Y, num7.X + (i * num6), num7.Y + num7.Height, this.stippleBitmapBrush, 1.0);
}
for (int j = -(rect.Height & 1); j <= rect.Height; j++)
{
dc.DrawLine(num7.X, num7.Y + (j * num6), num7.X + num7.Width, num7.Y + (j * num6), this.stippleBitmapBrush, 1.0);
}
}
}
}
}
base.OnRender(dc, clipRect, canvasView);
}
public void EnsureStrokeSamplesUpdated()
{
using (this.rwLock.UseWriteLock())
{
int num;
if (this.strokePath.Points.Count == 0)
{
num = 0;
}
else
{
double d = this.strokePath.Length / this.stampSpacingPx;
int num4 = (int)Math.Floor(d);
num = num4 + 1;
}
for (int i = this.strokeSamples.Count; i < num; i++)
{
double length = i * this.stampSpacingPx;
PointDouble pointAtLength = this.strokePath.GetPointAtLength(length);
BrushStrokeSample item = new BrushStrokeSample(pointAtLength, 1.0);
this.strokeSamples.Add(item);
SizeDouble size = new SizeDouble(this.stampSize.Width * item.StampScale, this.stampSize.Height * item.StampScale);
RectDouble bounds = RectDouble.FromCenter(item.Center, size);
Sprite <int> sprite = new Sprite <int>(bounds, i);
this.spriteTileSorter.Add(sprite);
}
}
}
protected override void OnRender(IDrawingContext dc, RectFloat clipRect)
{
dc.Clear(new ColorRgba128Float?(this.BackColor));
using (dc.UseTranslateTransform(0.5f, 0.5f, MatrixMultiplyOrder.Append))
{
RectDouble num = RectDouble.Inflate(base.ClientRectangle.ToRectInt32(), -1.0, -1.0);
double num3 = Math.Min(num.Width, num.Height) / 2.0;
PointDouble center = new PointDouble(num.X + num3, num.Y + num3);
double d = MathUtil.DegreesToRadians(this.value);
EllipseDouble ellipse = new EllipseDouble(center, num3 - 0.5, num3 - 0.5);
double thickness = this.hover ? 2.0 : 1.0;
double num8 = this.maxValue - this.minValue;
if (num8 >= 360.0)
{
dc.FillEllipse(ellipse, validAnglesFillBrush);
dc.DrawEllipse(ellipse, outlineBrush, thickness);
}
else
{
dc.FillEllipse(ellipse, invalidAnglesFillBrush);
double width = num3;
PointDouble num14 = new PointDouble(center.X + (width * Math.Cos(MathUtil.DegreesToRadians(this.minValue))), center.Y - (width * Math.Sin(MathUtil.DegreesToRadians(this.minValue))));
PointDouble num15 = new PointDouble(center.X + (width * Math.Cos(MathUtil.DegreesToRadians(this.maxValue))), center.Y - (width * Math.Sin(MathUtil.DegreesToRadians(this.maxValue))));
SizeDouble num16 = new SizeDouble(width, width);
if (this.validRangeGeometry == null)
{
this.validRangeGeometry = new PathGeometry();
this.validRangeFigure = new PathFigure();
this.validRangeFigure.IsFilled = true;
this.validRangeFigure.IsClosed = true;
this.validRangeGeometry.Figures.Add(this.validRangeFigure);
this.validRangeLineSegment1 = new LineSegment();
this.validRangeFigure.Segments.Add(this.validRangeLineSegment1);
this.validRangeArcSegment = new ArcSegment();
this.validRangeArcSegment.SweepDirection = SweepDirection.Counterclockwise;
this.validRangeFigure.Segments.Add(this.validRangeArcSegment);
this.validRangeLineSegment2 = new LineSegment();
this.validRangeFigure.Segments.Add(this.validRangeLineSegment2);
}
this.validRangeFigure.StartPoint = center;
this.validRangeLineSegment1.Point = num14;
this.validRangeArcSegment.Point = num15;
this.validRangeArcSegment.IsLargeArc = num8 >= 180.0;
this.validRangeArcSegment.Size = num16;
this.validRangeLineSegment2.Point = num15;
dc.FillGeometry(this.validRangeGeometry, validAnglesFillBrush, null);
dc.DrawEllipse(ellipse, outlineBrush, thickness);
dc.DrawLine(center, num14, outlineBrush, 0.5);
dc.DrawLine(center, num15, outlineBrush, 0.5);
}
double num9 = num3 - 2.0;
PointDouble num10 = new PointDouble(center.X + (num9 * Math.Cos(d)), center.Y - (num9 * Math.Sin(d)));
double radius = 2.5;
EllipseDouble num12 = new EllipseDouble(center, radius);
dc.FillEllipse(num12, gripFillBrush);
dc.DrawLine(center, num10, gripBrush, this.hover ? 2.0 : 1.5);
}
base.OnRender(dc, clipRect);
}
private void UpdateTileWhileLocked(TileData tileData, ICancellationToken cancelToken)
{
RectInt32 tileSourceRect = this.tileMathHelper.GetTileSourceRect(tileData.Offset);
RectDouble num2 = tileSourceRect;
cancelToken.ThrowIfCancellationRequested <ICancellationToken>();
object newCurrencyToken = this.renderData.CreateCurrencyToken();
cancelToken.ThrowIfCancellationRequested <ICancellationToken>();
IList <int?> list = this.renderData.GetStrokeSampleIndicesInRect(tileSourceRect, tileData.CurrencyToken, newCurrencyToken);
int count = list.Count;
if (count > 0)
{
SizeDouble size = this.stamp.Size;
RectDouble num5 = new RectDouble(PointDouble.Zero, size);
IDrawingContext dc = null;
try
{
for (int i = 0; i < count; i++)
{
int?nullable = list[i];
if (nullable.HasValue)
{
if (tileData.Mask == null)
{
cancelToken.ThrowIfCancellationRequested <ICancellationToken>();
tileData.Mask = new SurfaceAlpha8(tileSourceRect.Size);
}
if (tileData.MaskRenderTarget == null)
{
cancelToken.ThrowIfCancellationRequested <ICancellationToken>();
tileData.MaskRenderTarget = RenderTarget.FromSurface(tileData.Mask, FactorySource.PerThread);
}
if (dc == null)
{
cancelToken.ThrowIfCancellationRequested <ICancellationToken>();
dc = DrawingContext.FromRenderTarget(tileData.MaskRenderTarget);
dc.UseTranslateTransform((float)-tileSourceRect.X, (float)-tileSourceRect.Y, MatrixMultiplyOrder.Prepend);
dc.AntialiasMode = AntialiasMode.Aliased;
}
int valueOrDefault = nullable.GetValueOrDefault();
RectDouble bounds = this.renderData.StrokeSamples[valueOrDefault].GetBounds(size);
RectDouble num9 = this.stamp.Antialiased ? bounds : RectDouble.Round(bounds, MidpointRounding.AwayFromZero);
cancelToken.ThrowIfCancellationRequested <ICancellationToken>();
RectDouble?srcRect = null;
dc.FillOpacityMask(this.lazyStampMaskDevBitmap.CancelableValue <DeviceBitmap>(), whiteBrush, OpacityMaskContent.Graphics, new RectDouble?(num9), srcRect);
}
}
}
finally
{
DisposableUtil.Free <IDrawingContext>(ref dc);
}
}
tileData.CurrencyToken = newCurrencyToken;
}
protected override void OnRender(IDrawingContext dc)
{
PaintDotNet.UI.Media.DeviceBitmap deviceBitmap = this.DeviceBitmap;
if (deviceBitmap != null)
{
SizeDouble size = deviceBitmap.Size;
RectDouble num2 = new RectDouble(PointDouble.Zero, size);
dc.DrawBitmap(deviceBitmap, new RectDouble?(num2), 1.0, BitmapInterpolationMode.Linear, new RectDouble?(num2));
}
}
public BrushStrokeRenderData(SizeDouble stampSize, double stampSpacingPx, int tileEdgeLog2, BrushStrokeLengthMetric lengthMetric)
{
Validate.Begin().IsFinite(stampSize.Width, "stampSize.Width").IsFinite(stampSize.Height, "stampSize.Height").IsPositive(stampSize.Width, "stampSize.Width").IsPositive(stampSize.Height, "stampSize.Height").IsPositive(stampSpacingPx, "stampSpacingPx").IsNotNegative(tileEdgeLog2, "tileEdgeLog2").Check();
this.rwLock = new ReaderWriterLock();
this.spriteTileSorter = new SpriteTileSorter <int>(TransactedToolChanges.MaxMaxRenderBounds.Size, tileEdgeLog2);
this.strokePath = new BrushStrokePath(lengthMetric);
this.stampSize = stampSize;
this.stampSpacingPx = stampSpacingPx;
this.inputPoints = new SegmentedList <BrushInputPoint>();
this.inputPointsRO = new ReadOnlyCollection <BrushInputPoint>(this.inputPoints);
this.strokeSamples = new SegmentedList <BrushStrokeSample>();
this.strokeSamplesRO = new ReadOnlyCollection <BrushStrokeSample>(this.strokeSamples);
}
protected override void OnRender(IDrawingContext dc, RectFloat clipRect, CanvasView canvasView)
{
Matrix3x2Float transform = dc.Transform;
SizeDouble canvasSize = canvasView.CanvasSize;
RectFloat rect = new RectFloat(0f, 0f, (float)canvasSize.Width, (float)canvasSize.Height);
RectFloat num4 = transform.Transform(rect);
int recommendedExtent = this.dropShadowRenderer.GetRecommendedExtent(num4.Int32Bound.Size);
using (dc.UseTransform(Matrix3x2Float.Identity))
{
this.dropShadowRenderer.RenderOutside(dc, new ColorRgba128Float(0f, 0f, 0f, 0.5f), num4, recommendedExtent);
}
base.OnRender(dc, clipRect, canvasView);
}
protected override void OnRender(IDrawingContext dc, RectFloat clipRect, CanvasView canvasView)
{
SizeDouble canvasSize = canvasView.CanvasSize;
RectDouble num2 = RectDouble.FromEdges(-131072.0, 0.0, 0.0, canvasSize.Height);
RectDouble num3 = RectDouble.FromEdges(-131072.0, -131072.0, 131072.0, 0.0);
RectDouble num4 = RectDouble.FromEdges(canvasSize.Width, 0.0, 131072.0, canvasSize.Height);
RectDouble num5 = RectDouble.FromEdges(-131072.0, canvasSize.Height, 131072.0, 131072.0);
ColorRgba128Float num6 = (ThemeConfig.EffectiveTheme == PdnTheme.Aero) ? AeroColors.CanvasBackFillColor : ClassicColors.CanvasBackFillColor;
dc.Clear((RectFloat)num2, AntialiasMode.Aliased, new ColorRgba128Float?(num6));
dc.Clear((RectFloat)num3, AntialiasMode.Aliased, new ColorRgba128Float?(num6));
dc.Clear((RectFloat)num4, AntialiasMode.Aliased, new ColorRgba128Float?(num6));
dc.Clear((RectFloat)num5, AntialiasMode.Aliased, new ColorRgba128Float?(num6));
base.OnRender(dc, clipRect, canvasView);
}
RectInt32 IBitmapLayerTransactionHandlerHost <TDerived, TChanges> .GetDifferentialMaxBounds(TChanges oldChanges, TChanges newChanges)
{
object renderDataCurrencyToken = oldChanges.RenderDataCurrencyToken;
object newCurrencyToken = newChanges.RenderDataCurrencyToken;
IList <int> list = newChanges.RenderData.EnumerateStrokeSampleIndicesBetweenCurrencyTokens(renderDataCurrencyToken, newCurrencyToken);
if (list.Count == 0)
{
return(newChanges.GetMaxRenderBounds());
}
SizeDouble size = newChanges.Stamp.Size;
RectDouble bounds = newChanges.RenderData.StrokeSamples[list[0]].GetBounds(size);
int count = list.Count;
for (int i = 1; i < count; i++)
{
int num5 = list[i];
RectDouble b = newChanges.RenderData.StrokeSamples[num5].GetBounds(size);
bounds = RectDouble.Union(bounds, b);
}
return(bounds.Int32Bound);
}
private static PointDouble GetHandleCanvasOffset(PointInt32 point, SizeDouble actualSize) => new PointDouble((point.X + 0.5) - (actualSize.Width / 2.0), (point.Y + 0.5) - (actualSize.Height / 2.0));
public static SizeDouble ConvertViewportToCanvas(this CanvasView canvasView, SizeDouble viewportSize) => CanvasCoordinateConversions.ConvertViewportToCanvas(viewportSize, canvasView.ScaleRatio, canvasView.ViewportCanvasOffset);
public static SizeDouble ConvertCanvasToViewport(SizeDouble canvasSize, double scaleRatio, PointDouble viewportCanvasOffset) => ConvertExtentToViewport(ConvertCanvasToExtent(canvasSize, scaleRatio));
public static SizeDouble ConvertCanvasToExtent(SizeDouble canvasSize, double scaleRatio) => new SizeDouble(ConvertCanvasWidthToExtentWidth(canvasSize.Width, scaleRatio), ConvertCanvasHeightToExtentHeight(canvasSize.Height, scaleRatio));
public static SizeDouble ConvertViewportToExtent(SizeDouble viewportSize) => viewportSize;
public static SizeDouble ConvertViewportToCanvas(SizeDouble viewportSize, double scaleRatio, PointDouble viewportCanvasOffset) => ConvertExtentToCanvas(ConvertViewportToExtent(viewportSize), scaleRatio);
public static SizeDouble ConvertExtentToCanvas(this CanvasView canvasView, SizeDouble extentSize) => CanvasCoordinateConversions.ConvertExtentToCanvas(extentSize, canvasView.ScaleRatio);
public static SizeDouble ConvertExtentToViewport(this CanvasView canvasView, SizeDouble extentSize) => CanvasCoordinateConversions.ConvertExtentToViewport(extentSize);
protected override void OnKeyDown(KeyEventArgs e)
{
if (e.Handled)
{
goto Label_0347;
}
PaintDotNet.Canvas.CanvasView canvasView = this.CanvasView;
if (canvasView == null)
{
goto Label_0347;
}
bool flag = false;
switch (e.KeyCode)
{
case Keys.PageUp:
if (!e.Shift)
{
canvasView.ViewportCanvasOffset -= new VectorDouble(0.0, canvasView.ViewportCanvasBounds.Height);
}
else
{
canvasView.ViewportCanvasOffset -= new VectorDouble(canvasView.ViewportCanvasBounds.Width, 0.0);
}
flag = true;
e.Handled = true;
goto Label_032E;
case Keys.Next:
if (!e.Shift)
{
canvasView.ViewportCanvasOffset += new VectorDouble(0.0, canvasView.ViewportCanvasBounds.Height);
break;
}
canvasView.ViewportCanvasOffset += new VectorDouble(canvasView.ViewportCanvasBounds.Width, 0.0);
break;
case Keys.End:
if (!e.Control || !e.Alt)
{
if (e.Control)
{
canvasView.ViewportCanvasOffset = canvasView.ViewportCanvasOffsetMax;
}
else
{
RectDouble visibleCanvasBounds = canvasView.GetVisibleCanvasBounds();
SizeDouble size = canvasView.ViewportCanvasBounds.Size;
PointDouble bottomRight = canvasView.GetCanvasBounds().BottomRight;
if ((visibleCanvasBounds.Left <= (bottomRight.X - 1.0)) && (visibleCanvasBounds.Right >= bottomRight.X))
{
if ((visibleCanvasBounds.Top > (bottomRight.Y - 1.0)) || (visibleCanvasBounds.Bottom < bottomRight.Y))
{
canvasView.ViewportCanvasOffset = new PointDouble(canvasView.ViewportCanvasOffset.X, bottomRight.Y - size.Height);
}
}
else
{
canvasView.ViewportCanvasOffset = new PointDouble(bottomRight.X - size.Width, canvasView.ViewportCanvasOffset.Y);
}
}
}
flag = true;
e.Handled = true;
goto Label_032E;
case Keys.Home:
if (!e.Control || !e.Alt)
{
if (e.Control)
{
canvasView.ViewportCanvasOffset = canvasView.ViewportCanvasOffsetMin;
}
else
{
RectDouble num2 = canvasView.GetVisibleCanvasBounds();
PointDouble topLeft = canvasView.GetCanvasBounds().TopLeft;
if ((num2.Left <= topLeft.X) && (num2.Right >= (topLeft.X + 1.0)))
{
if ((num2.Top > topLeft.Y) || (num2.Bottom < (topLeft.Y + 1.0)))
{
canvasView.ViewportCanvasOffset -= new VectorDouble(0.0, num2.Top - topLeft.Y);
}
}
else
{
canvasView.ViewportCanvasOffset -= new VectorDouble(num2.Left - topLeft.X, 0.0);
}
}
}
flag = true;
e.Handled = true;
goto Label_032E;
default:
goto Label_032E;
}
flag = true;
e.Handled = true;
Label_032E:
if (flag)
{
canvasView.SetValue(PaintDotNet.Canvas.CanvasView.ViewportCanvasOffsetProperty, canvasView.GetValue(PaintDotNet.Canvas.CanvasView.ViewportCanvasOffsetProperty));
}
Label_0347:
base.OnKeyDown(e);
}
public static SizeDouble ConvertCanvasToExtent(this CanvasView canvasView, SizeDouble canvasSize) => CanvasCoordinateConversions.ConvertCanvasToExtent(canvasSize, canvasView.ScaleRatio);
private static PointDouble GetMoveHandleCanvasOffset(PointInt32 originPoint, double hairWidth, SizeDouble moveHandleActualSize)
{
VectorDouble vec = new VectorDouble(1.0, 1.0);
VectorDouble num3 = (VectorDouble)(VectorDouble.Normalize(vec) * (hairWidth * 25.0));
double x = UIUtil.ScaleWidth(num3.X);
VectorDouble num4 = new VectorDouble(x, UIUtil.ScaleHeight(num3.Y));
PointDouble num5 = new PointDouble((double)(originPoint.X + 1), (double)(originPoint.Y + 1));
PointDouble pt = num5 + num4;
return(PointDouble.Offset(pt, -moveHandleActualSize.Width / 2.0, -moveHandleActualSize.Height / 2.0));
}
public static SizeDouble ConvertViewportToExtent(this CanvasView canvasView, SizeDouble viewportSize) => CanvasCoordinateConversions.ConvertViewportToExtent(viewportSize);
public static SizeDouble ConvertCanvasToViewport(this CanvasView canvasView, SizeDouble canvasSize) => CanvasCoordinateConversions.ConvertCanvasToViewport(canvasSize, canvasView.ScaleRatio, canvasView.ViewportCanvasOffset);
private static PointDouble GetHandleCanvasOffset(PointDouble point, SizeDouble actualSize) => new PointDouble(point.X - (actualSize.Width / 2.0), point.Y - (actualSize.Height / 2.0));
private void RedrawOnBackgroundThread()
{
if (base.CheckAccess())
{
ExceptionUtil.ThrowInvalidOperationException();
}
if (this.redrawThreadFactory == null)
{
this.redrawThreadFactory = new Direct2DFactory(Direct2DFactoryType.MultiThreaded, DebugLevel.None);
}
if ((this.redrawThreadGeometryCache == null) || (this.redrawThreadGeometryCache.SelectionSnapshot != this.redrawRenderParams.SelectionSnapshot))
{
DisposableUtil.Free <SelectionGeometryCache>(ref this.redrawThreadGeometryCache);
this.redrawThreadGeometryCache = new SelectionGeometryCache(this.redrawThreadFactory, this.redrawRenderParams.SelectionSnapshot);
}
double scaleRatio = this.redrawRenderParams.ScaleRatio;
PointDouble location = this.redrawRenderParams.ViewportCanvasBounds.Location;
SizeDouble viewportSize = this.redrawRenderParams.ViewportSize;
SizeInt32 num5 = SizeDouble.Ceiling(viewportSize);
RectDouble b = RectDouble.Inflate(CanvasCoordinateConversions.ConvertExtentToViewport(CanvasCoordinateConversions.ConvertCanvasToExtent(this.redrawRenderParams.SelectionSnapshot.GeometryList.Value.Bounds, scaleRatio), scaleRatio, location), (double)this.outlineStrokeWidthPx, (double)this.outlineStrokeWidthPx);
RectDouble a = new RectDouble(PointDouble.Zero, viewportSize);
RectDouble renderViewportBounds = RectDouble.Intersect(a, b);
RectInt32 viewportRect = renderViewportBounds.Int32Bound;
RectDouble extentRect = CanvasCoordinateConversions.ConvertViewportToExtent(viewportRect, scaleRatio, location);
RectDouble renderCanvasBounds = CanvasCoordinateConversions.ConvertExtentToCanvas(extentRect, scaleRatio);
if (!viewportRect.HasPositiveArea)
{
base.SyncContext.Post((SendOrPostCallback)(_ => this.EndRedraw(renderViewportBounds, RectFloat.Zero, null, null)));
}
else
{
IBitmap <ColorAlpha8> interiorMask;
float scale;
PointFloat offset;
Result <IGeometry> lazyGeometry;
IBitmap <ColorAlpha8>[] dashedOutlineMasks;
RectFloat maskSourceRect;
SelectionSnapshot selectionSnapshot = this.redrawRenderParams.SelectionSnapshot;
SelectionGeometryCache redrawThreadGeometryCache = this.redrawThreadGeometryCache;
bool flag = this.redrawRenderParams.SelectionRenderingQuality == SelectionRenderingQuality.Aliased;
if (!flag)
{
lazyGeometry = redrawThreadGeometryCache.Geometry;
}
else
{
bool flag3 = selectionSnapshot.IsRectilinear.Value;
bool flag4 = selectionSnapshot.IsPixelated.Value;
if (flag3 & flag4)
{
lazyGeometry = redrawThreadGeometryCache.Geometry;
}
else
{
lazyGeometry = redrawThreadGeometryCache.PixelatedGeometry;
}
}
bool flag2 = !flag && this.redrawRenderParams.IsOutlineAntialiased;
AntialiasMode antialiasMode = ((flag || !flag2) || selectionSnapshot.IsRectilinear.Value) ? AntialiasMode.Aliased : AntialiasMode.PerPrimitive;
if (this.CanContinueRedrawing(null, null))
{
scale = (float)this.redrawRenderParams.ScaleRatio;
float x = -((float)renderCanvasBounds.X);
float y = -((float)renderCanvasBounds.Y);
offset = new PointFloat(x, y);
interiorMask = BitmapAllocator.Alpha8.Allocate(viewportRect.Size, AllocationOptions.ZeroFillNotRequired);
try
{
RetryManager.RunMemorySensitiveOperation(delegate {
using (IDrawingContext context = DrawingContext.FromBitmap(this.redrawThreadFactory, interiorMask))
{
context.Clear(null);
IBrush interiorBrush = context.GetCachedOrCreateResource <IBrush>(whiteBrush);
this.RenderSelection(context, scale, offset, this.redrawRenderParams, lazyGeometry, interiorBrush, null, null, antialiasMode);
}
});
}
catch (OutOfMemoryException)
{
}
if (this.CanContinueRedrawing(interiorMask, null))
{
int num15;
dashedOutlineMasks = new IBitmap <ColorAlpha8> [SelectionCanvasLayer.DashLength];
for (int i = 0; i < dashedOutlineMasks.Length; i = num15)
{
if ((!this.redrawRenderParams.IsOutlineAnimated && (i != 0)) && (i != (SelectionCanvasLayer.DashLength / 2)))
{
dashedOutlineMasks[i] = null;
}
else
{
dashedOutlineMasks[i] = BitmapAllocator.Alpha8.Allocate(viewportRect.Size, AllocationOptions.ZeroFillNotRequired);
try
{
RetryManager.RunMemorySensitiveOperation(delegate {
using (IDrawingContext context = DrawingContext.FromBitmap(this.redrawThreadFactory, dashedOutlineMasks[i]))
{
context.Clear(null);
StrokeStyle resourceSource = SelectionCanvasLayer.GetDashedStrokeStyle(i);
IStrokeStyle outlineStrokeStyle = context.GetCachedOrCreateResource <IStrokeStyle>(resourceSource);
IBrush cachedOrCreateResource = context.GetCachedOrCreateResource <IBrush>(whiteBrush);
this.RenderSelection(context, scale, offset, this.redrawRenderParams, lazyGeometry, null, cachedOrCreateResource, outlineStrokeStyle, antialiasMode);
}
});
}
catch (OutOfMemoryException)
{
}
if (!this.CanContinueRedrawing(interiorMask, dashedOutlineMasks))
{
return;
}
}
num15 = i + 1;
}
maskSourceRect = new RectFloat(PointFloat.Zero, interiorMask.Size);
base.SyncContext.Post(_ => this.EndRedraw(renderCanvasBounds, maskSourceRect, interiorMask, dashedOutlineMasks), null);
}
}
}
}
private bool OnLayoutImpl()
{
Rectangle clientRectangle = base.ClientRectangle;
Size size = clientRectangle.Size;
if ((size.Width >= 0) && (size.Height >= 0))
{
RectDouble viewportRect = clientRectangle.ToRectDouble();
SizeDouble num2 = size.ToSizeDouble();
int horizontalScrollBarHeight = SystemInformation.HorizontalScrollBarHeight;
int verticalScrollBarWidth = SystemInformation.VerticalScrollBarWidth;
PaintDotNet.Canvas.Canvas canvas = this.canvasControl.Canvas;
PaintDotNet.Canvas.CanvasView canvasView = this.canvasControl.CanvasView;
SizeDouble canvasSize = canvasView.CanvasSize;
RectDouble canvasBounds = canvasView.GetCanvasBounds();
SizeDouble viewportSize = canvasView.ViewportSize;
SizeDouble num9 = canvasView.ViewportCanvasBounds.Size;
PointDouble viewportCanvasOffset = canvasView.ViewportCanvasOffset;
PointDouble viewportCanvasOffsetMin = canvasView.ViewportCanvasOffsetMin;
PointDouble viewportCanvasOffsetMax = canvasView.ViewportCanvasOffsetMax;
SizeDouble num14 = canvasView.ConvertViewportToCanvas(viewportRect).Size;
SizeDouble num15 = new SizeDouble(Math.Max((double)0.0, (double)(num2.Width - verticalScrollBarWidth)), Math.Max((double)0.0, (double)(num2.Height - horizontalScrollBarHeight)));
RectDouble num16 = new RectDouble(viewportRect.Location, num15);
SizeDouble num18 = canvasView.ConvertViewportToCanvas(num16).Size;
ThicknessDouble frameCanvasPadding = canvasView.FrameCanvasPadding;
RectDouble framedCanvasBounds = canvasView.FramedCanvasBounds;
bool flag = false;
bool flag2 = false;
if ((this.canvasControl == null) || (canvasView.ScaleBasis == ScaleBasis.FitToViewport))
{
flag = false;
flag2 = false;
}
else
{
if (framedCanvasBounds.Width > num14.Width)
{
flag = true;
if (framedCanvasBounds.Height > num18.Height)
{
flag2 = true;
}
}
if (framedCanvasBounds.Height > num14.Height)
{
flag2 = true;
if (framedCanvasBounds.Width > num18.Width)
{
flag = true;
}
}
}
int num21 = size.Width - (flag2 ? verticalScrollBarWidth : 0);
int width = Math.Max(0, num21);
int num23 = size.Height - (flag ? horizontalScrollBarHeight : 0);
int height = Math.Max(0, num23);
Rectangle rectangle2 = new Rectangle(0, 0, width, height);
double scaleRatio = canvasView.ScaleRatio;
this.canvasControl.Bounds = rectangle2;
this.canvasControl.PerformLayout();
canvasView.CoerceValue(PaintDotNet.Canvas.CanvasView.ScaleRatioProperty);
if ((canvasView.ScaleRatio != scaleRatio) || (canvasView.ViewportSize != viewportSize))
{
return(false);
}
if (flag)
{
Rectangle newBounds = new Rectangle(0, size.Height - horizontalScrollBarHeight, size.Width - (flag2 ? verticalScrollBarWidth : 0), horizontalScrollBarHeight);
int min = this.ConvertToScrollBar(viewportCanvasOffsetMin.X);
int max = this.ConvertToScrollBar(viewportCanvasOffsetMax.X + num9.Width);
int newLargeChange = this.ConvertToScrollBar(num9.Width);
int newSmallChange = this.ConvertToScrollBar(num9.Width / 10.0);
int newValue = Int32Util.Clamp(this.ConvertToScrollBar(viewportCanvasOffset.X), min, max);
UpdateScrollBar(this.hScrollBar, newBounds, min, max, newLargeChange, newSmallChange, newValue);
}
if (flag2)
{
Rectangle rectangle4 = new Rectangle(size.Width - verticalScrollBarWidth, 0, verticalScrollBarWidth, size.Height - (flag ? horizontalScrollBarHeight : 0));
int num31 = this.ConvertToScrollBar(viewportCanvasOffsetMin.Y);
int num32 = this.ConvertToScrollBar(viewportCanvasOffsetMax.Y + num9.Height);
int num33 = this.ConvertToScrollBar(num9.Height);
int num34 = this.ConvertToScrollBar(num9.Height / 10.0);
int num35 = Int32Util.Clamp(this.ConvertToScrollBar(viewportCanvasOffset.Y), num31, num32);
UpdateScrollBar(this.vScrollBar, rectangle4, num31, num32, num33, num34, num35);
}
this.hScrollBar.Visible = flag;
this.vScrollBar.Visible = flag2;
}
return(true);
}
public static SizeDouble ConvertExtentToCanvas(SizeDouble extentSize, double scaleRatio)
{
double width = ConvertExtentWidthToCanvasWidth(extentSize.Width, scaleRatio);
return(new SizeDouble(width, ConvertExtentHeightToCanvasHeight(extentSize.Height, scaleRatio)));
}
public SelectionRenderParameters(PaintDotNet.Canvas.SelectionSnapshot selectionSnapshot, SizeDouble canvasSize, SizeDouble viewportSize, RectDouble viewportCanvasBounds, double scaleRatio, bool isInteriorFilled, Brush interiorBrush, bool isOutlineEnabled, bool isOutlineAntialiased, bool isOutlineAnimated, PaintDotNet.SelectionRenderingQuality selectionRenderingQuality)
{
this.SelectionSnapshot = selectionSnapshot;
this.CanvasSize = canvasSize;
this.ViewportSize = viewportSize;
this.ViewportCanvasBounds = viewportCanvasBounds;
this.ScaleRatio = scaleRatio;
this.IsInteriorFilled = isInteriorFilled;
this.InteriorBrush = interiorBrush;
this.IsOutlineEnabled = isOutlineEnabled;
this.IsOutlineAntialiased = isOutlineAntialiased;
this.IsOutlineAnimated = isOutlineAnimated;
this.SelectionRenderingQuality = selectionRenderingQuality;
}
public static SizeDouble ConvertExtentToViewport(SizeDouble extentSize) => extentSize;
