private void UpdateRenderingPriority()
{
IRenderTarget renderTarget = base.RenderTarget;
if ((renderTarget != null) && renderTarget.IsSupported(RenderTargetType.Hardware, null, null, null))
{
using (CastOrRefHolder <IDeviceContext> holder = renderTarget.TryCastOrCreateRef <IDeviceContext>())
{
if (holder.HasRef)
{
using (CastOrRefHolder <IDevice1> holder2 = holder.ObjectRef.Device.TryCastOrCreateRef <IDevice1>())
{
if (holder2.HasRef)
{
RenderingPriority renderingPriority = holder2.ObjectRef.RenderingPriority;
RenderingPriority priority2 = RenderingPriorityManager.RenderingPriority;
if (renderingPriority != priority2)
{
holder2.ObjectRef.RenderingPriority = priority2;
}
}
}
}
}
}
}
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 ((this.brushSize > 0.0) && (this.brushAlpha > 0))
{
double opacity = ((double)this.brushAlpha) / 255.0;
Brush brush = SolidColorBrushCache.Get((ColorRgba128Float)ColorBgra.White, opacity);
Brush brush2 = SolidColorBrushCache.Get((ColorRgba128Float)ColorBgra.Black, opacity);
double canvasHairWidth = canvasView.CanvasHairWidth;
RectDouble brushRect = this.BrushRect;
brushRect.Inflate((double)(-canvasHairWidth * 2.0), (double)(-canvasHairWidth * 2.0));
if (brushRect.HasPositiveArea)
{
this.ellipseGeometryInner.RadiusX = this.brushSize - (canvasHairWidth * 2.0);
this.ellipseGeometryInner.RadiusY = this.brushSize - (canvasHairWidth * 2.0);
this.ellipseGeometryMiddle.RadiusX = this.brushSize - canvasHairWidth;
this.ellipseGeometryMiddle.RadiusY = this.brushSize - canvasHairWidth;
this.ellipseGeometryOuter.RadiusX = this.brushSize;
this.ellipseGeometryOuter.RadiusY = this.brushSize;
using (dc.UseTranslateTransform(-((VectorFloat)this.brushLocation), MatrixMultiplyOrder.Prepend))
{
using (CastOrRefHolder <IDrawingContext2> holder = dc.TryCastOrCreateRef <IDrawingContext2>())
{
if (holder.HasRef)
{
this.ellipseRealizationInner = this.ellipseRealizationInner ?? new StrokedGeometryRealization(this.ellipseGeometryInner);
this.ellipseRealizationMiddle = this.ellipseRealizationMiddle ?? new StrokedGeometryRealization(this.ellipseGeometryMiddle);
this.ellipseRealizationOuter = this.ellipseRealizationOuter ?? new StrokedGeometryRealization(this.ellipseGeometryOuter);
this.ellipseRealizationInner.Thickness = canvasHairWidth;
this.ellipseRealizationMiddle.Thickness = canvasHairWidth;
this.ellipseRealizationOuter.Thickness = canvasHairWidth;
holder.ObjectRef.DrawGeometryRealization(this.ellipseRealizationInner, brush);
holder.ObjectRef.DrawGeometryRealization(this.ellipseRealizationMiddle, brush2);
holder.ObjectRef.DrawGeometryRealization(this.ellipseRealizationOuter, brush);
}
else
{
dc.DrawGeometry(this.ellipseGeometryInner, brush, canvasHairWidth);
dc.DrawGeometry(this.ellipseGeometryMiddle, brush2, canvasHairWidth);
dc.DrawGeometry(this.ellipseGeometryOuter, brush, canvasHairWidth);
}
}
}
}
}
base.OnRender(dc, clipRect, canvasView);
}
