/// <summary> /// This method is called just after the Piccolo scene graph is painted. /// </summary> /// <param name="paintContext">The paint context used to paint the scene graph.</param> public static void EndProcessingOutput(PPaintContext paintContext) { processOutputTime += (PUtil.CurrentTimeMillis - startProcessingOutputTime); framesProcessed++; if (PDebug.debugPrintFrameRate) { if (framesProcessed % printResultsFrameRate == 0) { System.Console.WriteLine("Process output frame rate: " + OutputFPS + " fps"); System.Console.WriteLine("Process input frame rate: " + InputFPS + " fps"); System.Console.WriteLine("Total frame rate: " + TotalFPS + " fps"); System.Console.WriteLine(); ResetFPSTiming(); } } if (PDebug.debugPrintUsedMemory) { if (framesProcessed % printResultsFrameRate == 0) { System.Console.WriteLine("Approximate used memory: " + ApproximateUsedMemory / 1024 + " k"); } } if (PDebug.debugRegionManagement) { paintContext.PaintClipRegion(new SolidBrush(DebugPaintColor)); } processingOutput = false; }
//**************************************************************** // Painting - Methods for painting a PText. //**************************************************************** /// <summary> /// Overridden. See <see cref="PNode.Paint">PNode.Paint</see>. /// </summary> protected override void Paint(UMD.HCIL.Piccolo.Util.PPaintContext paintContext) { base.Paint(paintContext); if (text != null && textBrush != null && font != null) { Graphics g = paintContext.Graphics; float renderedFontSize = font.SizeInPoints * paintContext.Scale; if (renderedFontSize < PUtil.GreekThreshold) { // .NET bug: DrawString throws a generic gdi+ exception when // the scaled font size is very small. So, we will render // the text as a simple rectangle for small fonts g.FillRectangle(textBrush, Bounds); } else if (renderedFontSize < PUtil.MaxFontSize) { Font renderFont = font; // The font needs to be adjusted for printing. //TODO: Remove HighDPI scaling for this as we have zoom controller if (g.DpiY != GRAPHICS.DpiY) { float fPrintedFontRatio = GRAPHICS.DpiY / 100; renderFont = new Font(font.Name, font.Size * fPrintedFontRatio, font.Style, font.Unit); } g.DrawString(text, renderFont, textBrush, Bounds, stringFormat); } } }
/// <summary> /// Constructs a new PPaintContext. /// </summary> /// <param name="graphics"> /// The graphics context to associate with this paint context. /// </param> /// <param name="canvas">The canvas that the paint context will render on.</param> public PPaintContext(Graphics graphics, PCanvas canvas) { this.graphics = graphics; this.canvas = canvas; clipStack = new Stack(); localClipStack = new Stack(); cameraStack = new Stack(); transformStack = new Stack(); RenderQuality = RenderQuality.HighQuality; CURRENT_PAINT_CONTEXT = this; InitializeStacks(); }
//**************************************************************** // Painting - Methods for painting a PText. //**************************************************************** /// <summary> /// Overridden. See <see cref="PNode.Paint">PNode.Paint</see>. /// </summary> protected override void Paint(UMD.HCIL.Piccolo.Util.PPaintContext paintContext) { base.Paint(paintContext); Device device = (paintContext as P3PaintContext).Device; PMatrix currMatrix = (paintContext as P3PaintContext).Transform; // Scale the matrix down to display font units float scale = displayFontSize / font.Size; currMatrix.ScaleBy(scale, X, Y); float[] piccoloMatrixElements = currMatrix.Elements; if (!currMatrix.IsIdentity) { Matrix m = new Matrix(); m.M11 = piccoloMatrixElements[0]; m.M12 = piccoloMatrixElements[1]; m.M21 = piccoloMatrixElements[2]; m.M22 = piccoloMatrixElements[3]; m.M41 = piccoloMatrixElements[4]; m.M42 = piccoloMatrixElements[5]; m.M33 = 1; m.M44 = 1; textSprite.Transform = m; } textSprite.Begin(SpriteFlags.None); DrawTextFormat D3DAlignment = P3Util.GetD3DAlignment(stringFormat.Alignment); // Calculate the rectangle with no padding, in actual font units scale = 1 / scale; int totHzPadding = currLeftPadding + currRightPadding; int totVtPadding = currTopPadding + currBottomPadding; Rectangle dstRect = new Rectangle((int)(Bounds.X + currLeftPadding * scale), (int)(Bounds.Y + currTopPadding * scale), (int)((Bounds.Width - totHzPadding) * scale), (int)((Bounds.Height - totVtPadding) * scale)); // Wrap the string ourselves, instead of letting the draw method do it, since we want to make // sure it's consistent with our own MeasureString method. String str = P3Util.WrapString(textSprite, D3Dfont, Text, dstRect.Width, (TextBrush as SolidBrush).Color); D3Dfont.DrawText(textSprite, str, dstRect, D3DAlignment, (TextBrush as SolidBrush).Color); textSprite.End(); }
protected override void Paint(UMD.HCIL.Piccolo.Util.PPaintContext paintContext) { Graphics graphics = paintContext.Graphics; Brush brush = Brush; if (brush == null) { if (ChildrenCount == 0) { brush = new SolidBrush(Color.FromArgb(170, Color.White)); } else { brush = new SolidBrush(Color.FromArgb(0, Color.White)); } } brush = new SolidBrush(Color.FromArgb(0, Color.White)); float x = Model.X; float y = Model.Y; float width = Model.Width; float height = Model.Height; graphics.FillRectangle(brush, x, y, width, height); Pen pen = new Pen(Brushes.Gray, 1); pen.DashStyle = System.Drawing.Drawing2D.DashStyle.Dash; if (Frame.ShowAxis) { pen.Brush = Brushes.SkyBlue; pen.Width = 1; pen.DashOffset = 30; graphics.DrawLine(pen, x, y, x + width, y + height); graphics.DrawLine(pen, x, y + height, x + width, y); } }
/// <summary> /// Overridden. See <see cref="PCamera.PaintDebugBounds">PCamera.PaintDebugBounds</see>. /// </summary> protected override void PaintDebugBounds(PPaintContext paintContext, Pen boundsPen, RectangleF nodeBounds) { Device device = (paintContext as P3PaintContext).Device; CustomVertex.PositionColored[] colVerts = new CustomVertex.PositionColored[VERTEX_COUNT]; P3Util.CreateColoredRectangleOutline(colVerts, 0, nodeBounds, boundsPen.Color.ToArgb()); device.VertexFormat = CustomVertex.PositionColored.Format; device.DrawUserPrimitives(PrimitiveType.LineStrip, 4, colVerts); }
protected override void Paint(PPaintContext paintContext) { Graphics g = paintContext.Graphics; g.DrawRectangle(Pens.Black, Bounds.X, Bounds.Y, Bounds.Width, Bounds.Height); float y = (float) Y + CalendarNode.TEXT_Y_OFFSET; g.DrawString(dayOfMonthString, CalendarNode.DEFAULT_FONT, Brush, (float) X + CalendarNode.TEXT_X_OFFSET, y); if (hasWidthFocus && hasHeightFocus) { paintContext.PushClip(new Region(Bounds)); for (int i = 0; i < lines.Count; i++) { y += 10; g.DrawString((String)lines[i], CalendarNode.DEFAULT_FONT, Brush, X + CalendarNode.TEXT_X_OFFSET, y); } paintContext.PopClip(); } }
/// <summary> /// Overridden. See <see cref="PNode.Paint">PNode.Paint</see>. /// </summary> protected override void Paint(PPaintContext paintContext) { base.Paint (paintContext); Graphics g = paintContext.Graphics; PMatrix matrix = new PMatrix(g.Transform); RectangleF transRectF = matrix.Transform(bounds); Rectangle transRect = new Rectangle((int)transRectF.X, (int)transRectF.Y, (int)transRectF.Width, (int)transRectF.Height); // Draw the image if the control node is not in editing mode or // if the control is being rendered in a view other than the one // that owns the control. if (!Editing || control.Bounds != transRect || paintContext.Canvas != currentCanvas) { if (Image != null) g.DrawImage(Image, bounds); } }
/// <summary> /// Scale the Graphics so that this node's full bounds fit in displayRect and then /// render into the given Graphics context. /// </summary> /// <param name="g">The Graphics context to use when rendering the node.</param> /// <param name="displayRect">The imageable area.</param> protected virtual void ScaleAndDraw(Graphics g, RectangleF displayRect) { RectangleF bounds = FullBounds; g.TranslateTransform(displayRect.X, displayRect.Y); // scale the graphics so node's full bounds fit in the imageable bounds. float scale = displayRect.Width / bounds.Width; if (displayRect.Height / bounds.Height < scale) { scale = displayRect.Height / bounds.Height; } g.ScaleTransform(scale, scale); g.TranslateTransform(-bounds.X, -bounds.Y); PPaintContext pc = new PPaintContext(g, null); pc.RenderQuality = RenderQuality.HighQuality; FullPaint(pc); }
/// <summary> /// Paint this node and all of its descendents. /// </summary> /// <param name="paintContext">The paint context to use for painting this node.</param> /// <remarks> /// <b>Notes to Inheritors:</b> Most subclasses do not need to override this method, /// they should override <c>paint</c> or <c>paintAfterChildren</c> instead. /// </remarks> public virtual void FullPaint(PPaintContext paintContext) { if (Visible && FullIntersects(paintContext.LocalClip)) { paintContext.PushMatrix(matrix); //paintContext.PushTransparency(transparency); if (!Occluded) { Paint(paintContext); } int count = ChildrenCount; for (int i = 0; i < count; i++) { children[i].FullPaint(paintContext); } PaintAfterChildren(paintContext); //paintContext.popTransparency(transparency); paintContext.PopMatrix(); } }
/// <summary> /// Overridden. Begins the Direct3D scene, paints Piccolo and ends the Direct3D scene. /// </summary> /// <param name="paintContext">The paint context to use for painting piccolo.</param> protected override void PaintPiccolo(PPaintContext paintContext) { if (device != null) { device.Clear(ClearFlags.Target, BackColor, 1.0f, 0); device.BeginScene(); // Begin the scene. base.PaintPiccolo (paintContext); device.EndScene(); // End the scene. device.Present(); } }
//**************************************************************** // Painting - Methods for painting a PPathwayObject. //**************************************************************** /// <summary> /// Overridden. See <see cref="PNode.Paint">PNode.Paint</see>. /// </summary> protected override void Paint(PPaintContext paintContext) { Brush b = this.Brush; System.Drawing.Graphics g = paintContext.Graphics; if (b != null) { g.FillPath(b, m_path); } if (m_pen != null) { g.DrawPath(m_pen, m_path); } }
protected override void Paint(PPaintContext paintContext) { // make sure grid gets drawn on snap to grid boundaries. And // expand a little to make sure that entire view is filled. float bx = (X - (X % gridSpacing)) - gridSpacing; float by = (Y - (Y % gridSpacing)) - gridSpacing; float rightBorder = X + Width + gridSpacing; float bottomBorder = Y + Height + gridSpacing; Graphics g = paintContext.Graphics; RectangleF clip = paintContext.LocalClip; for (float x = bx; x < rightBorder; x += gridSpacing) { gridLine.Reset(); gridLine.AddLine(x, by, x, bottomBorder); if (PUtil.RectIntersectsPerpLine(clip, x, by, x, bottomBorder)) { g.DrawPath(gridPen, gridLine); } } for (float y = by; y < bottomBorder; y += gridSpacing) { gridLine.Reset(); gridLine.AddLine(bx, y, rightBorder, y); if (PUtil.RectIntersectsPerpLine(clip, bx, y, rightBorder, y)) { g.DrawPath(gridPen, gridLine); } } }
//**************************************************************** // Painting - Methods for painting a PImage. //**************************************************************** /// <summary> /// Overridden. See <see cref="PNode.Paint">PNode.Paint</see>. /// </summary> protected override void Paint(PPaintContext paintContext) { if (Image != null) { RectangleF b = Bounds; Graphics g = paintContext.Graphics; g.DrawImage(image, b); } }
/// <summary> /// Overridden. Pops the clip from the paint context and then renders the outline /// of this node. /// </summary> /// <param name="paintContext"> /// The paint context to use for painting this node. /// </param> protected override void PaintAfterChildren(PPaintContext paintContext) { paintContext.PopClip(); if (Pen != null) { Graphics g = paintContext.Graphics; g.DrawPath(Pen, PathReference); } }
/// <summary> /// Overridden. Renders the fill for this node and then pushes the clip onto the /// paint context, so that when this node's children are rendered they will be /// clipped accordingly. /// </summary> /// <param name="paintContext"> /// The paint context to use for painting this node. /// </param> protected override void Paint(PPaintContext paintContext) { Brush b = Brush; if (b != null) { Graphics g = paintContext.Graphics; g.FillPath(b, this.PathReference); } TEMP_REGION.MakeInfinite(); TEMP_REGION.Intersect(PathReference); paintContext.PushClip(TEMP_REGION); }
protected override void Paint(PPaintContext paintContext) { base.Paint (paintContext); Graphics g = paintContext.Graphics; if (hilite) { g.DrawRectangle(Pens.Red, X, Y, Width, Height); if (Tag != null) { g.DrawString(((int)Tag).ToString(), font, Brushes.Black, Bounds.Right-60, Bounds.Bottom-55); } } }
/// <summary> /// This method is called just after the Piccolo scene graph is painted. /// </summary> /// <param name="paintContext">The paint context used to paint the scene graph.</param> public static void EndProcessingOutput(PPaintContext paintContext) { processOutputTime += (PUtil.CurrentTimeMillis - startProcessingOutputTime); framesProcessed++; if (PDebug.debugPrintFrameRate) { if (framesProcessed % printResultsFrameRate == 0) { System.Console.WriteLine("Process output frame rate: " + OutputFPS + " fps"); System.Console.WriteLine("Process input frame rate: " + InputFPS + " fps"); System.Console.WriteLine("Total frame rate: " + TotalFPS + " fps"); System.Console.WriteLine(); ResetFPSTiming(); } } if (PDebug.debugPrintUsedMemory) { if (framesProcessed % printResultsFrameRate == 0) { System.Console.WriteLine("Approximate used memory: " + ApproximateUsedMemory / 1024 + " k"); } } if (PDebug.debugRegionManagement) { paintContext.PaintClipRegion(new SolidBrush(DebugPaintColor)); } processingOutput = false; }
/// <summary> /// Overridden. Does fast rendering when possible. /// </summary> public override void FullPaint(PPaintContext paintContext) { if (imageAnimate) { RectangleF fRef = FullBounds; RectangleF viewBounds = ViewBounds; float scale = FullBounds.Width/imageAnimateBounds.Width; float xOffset = (viewBounds.X-imageAnimateBounds.X)*scale; float yOffset = (viewBounds.Y-imageAnimateBounds.Y)*scale; float scaleW = viewBounds.Width*scale; float scaleH = viewBounds.Height*scale; RectangleF destRect = new RectangleF(0,0,(int)Math.Ceiling(fRef.Width),(int)Math.Ceiling(fRef.Height)); RectangleF srcRect = new RectangleF((int)Math.Floor(xOffset),(int)Math.Floor(yOffset),(int)Math.Ceiling(xOffset+scaleW),(int)Math.Ceiling(yOffset+scaleH)); paintContext.Graphics.DrawImage(paintBuffer, destRect, srcRect, GraphicsUnit.Pixel); } else { base.FullPaint(paintContext); } }
protected override void Paint(PPaintContext paintContext) { paintContext.Graphics.TextRenderingHint = System.Drawing.Text.TextRenderingHint.SingleBitPerPixel; if (shadowRendering && base.Text != null && base.TextBrush != null && base.Font != null) { Graphics g = paintContext.Graphics; float renderedFontSize = base.Font.SizeInPoints * paintContext.Scale; if(paintContext.Scale >= 1) if (renderedFontSize >= PUtil.GreekThreshold && renderedFontSize < PUtil.MaxFontSize) { RectangleF shadowbounds = new RectangleF(); shadowbounds = Bounds; shadowbounds.Offset(1, 1); StringFormat stringformat = new StringFormat(); stringformat.Alignment = base.TextAlignment; g.DrawString(base.Text, base.Font, black, shadowbounds, stringformat); } } base.Paint(paintContext); }
/// <summary> /// Paints the piccolo hierarchy. /// </summary> /// <remarks> /// Subclasses that add painting code should override this method rather than /// <see cref="PCanvas.OnPaint">PCanvas.OnPaint</see> to ensure that any extra processing /// will be included in the output frame rate calculation. /// </remarks> /// <param name="paintContext">The paint context to use for painting piccolo.</param> protected virtual void PaintPiccolo(PPaintContext paintContext) { // create new paint context and set render quality to lowest common // denominator render quality. if (Interacting || Animating) { if (interactingRenderQuality < animatingRenderQuality) { paintContext.RenderQuality = interactingRenderQuality; } else { paintContext.RenderQuality = animatingRenderQuality; } } else { paintContext.RenderQuality = defaultRenderQuality; } // paint camera.FullPaint(paintContext); // if switched state from animating to not animating invalidate the entire // screen so that it will be drawn with the default instead of animating // render quality. if (!Animating && animatingOnLastPaint) { Invalidate(); } animatingOnLastPaint = Animating; }
/// <summary> /// Constructs a new PPaintContext. /// </summary> /// <param name="graphics"> /// The graphics context to associate with this paint context. /// </param> /// <param name="canvas">The canvas that the paint context will render on.</param> public PPaintContext(Graphics graphics, PCanvas canvas) { this.graphics = graphics; this.canvas = canvas; clipStack = new Stack(); localClipStack = new Stack(); cameraStack = new Stack(); transformStack = new Stack(); RenderQuality = RenderQuality.HighQuality; CURRENT_PAINT_CONTEXT = this; InitializeStacks(); }
/// <summary> /// Overridden. See <see cref="PNode.Paint">PNode.Paint</see>. /// </summary> protected override void Paint(PPaintContext paintContext) { // Only paint the node if the brush is not null. if (Brush != null) { Device device = (paintContext as P3PaintContext).Device; if (device != null) { device.SetStreamSource(0, GetValidVertexBuffer(device), 0); device.VertexFormat = CustomVertex.PositionColored.Format; device.DrawPrimitives(PrimitiveType.TriangleList, VERTEX_INDEX, 2); } } }
/// <summary> /// Paint this node behind any of its children nodes. /// </summary> /// <param name="paintContext">The paint context to use for painting this node.</param> /// <remarks> /// <b>Notes to Inheritors:</b> Subclasses that define a different appearance should /// override this method and paint themselves there. /// </remarks> protected virtual void Paint(PPaintContext paintContext) { if (Brush != null) { Graphics g = paintContext.Graphics; g.FillRectangle(Brush, Bounds); } }
protected override void Paint(PPaintContext paintContext) { if (fIsPressed) { Graphics g = paintContext.Graphics; g.FillRectangle(this.Brush, this.Bounds); } else { base.Paint(paintContext); } }
/// <summary> /// Subclasses that wish to do additional painting after their children /// are painted should override this method and do that painting here. /// </summary> /// <param name="paintContext"> /// The paint context to use for painting after the children are painted. /// </param> protected virtual void PaintAfterChildren(PPaintContext paintContext) { }
protected override void Paint(PPaintContext paintContext) { float bx = X; float by = Y; float rightBorder = bx + Width; float bottomBorder = by + Height; GraphicsPath line = new GraphicsPath(); Graphics g = paintContext.Graphics; Pen pen = new Pen(this.Brush, 0); // draw vertical lines for (float x = bx; x < rightBorder; x += 5) { line.Reset(); line.AddLine(x, by, x, bottomBorder); g.DrawPath(pen, line); } for (float y = by; y < bottomBorder; y += 5) { line.Reset(); line.AddLine(bx, y, rightBorder, y); g.DrawPath(pen, line); } }
/// <summary> /// Overridden. See <see cref="PNode.Paint">PNode.Paint</see>. /// </summary> protected override void Paint(PPaintContext paintContext) { Graphics g = paintContext.Graphics; float x = X; float y = Y; float width = Width; float height = Height; float[] elements = g.Transform.Elements; float magX = elements[0]; float magY = elements[3]; float dx = (float)(1.0 / magX); float dy = (float)(1.0 / magY); g.FillRectangle(Brush, Bounds); path.Reset(); path.AddLine((float)(x+width), (float)y, (float)x, (float)y); path.AddLine((float)x, (float)y, (float)x, (float)(y+height)); pen.Color = topLeftOuterColor; g.DrawPath(pen, path); path.Reset(); path.AddLine((float)(x+width), (float)(y+dy), (float)(x+dx), (float)(y+dy)); path.AddLine((float)(x+dx), (float)(y+dy), (float)(x+dx), (float)(y+height)); pen.Color = topLeftInnerColor; g.DrawPath(pen, path); path.Reset(); path.AddLine((float)(x+width), (float)(y), (float)(x+width), (float)(y+height)); path.AddLine((float)(x+width), (float)(y+height), (float)(x), (float)(y+height)); pen.Color = bottomRightOuterColor; g.DrawPath(pen, path); path.Reset(); path.AddLine((float)(x+width-dx), (float)(y+dy), (float)(x+width-dx), (float)(y+height-dy)); path.AddLine((float)(x+width-dx), (float)(y+height-dy), (float)(x), (float)(y+height-dy)); pen.Color = bottomRightInnerColor; g.DrawPath(pen, path); }
/// <summary> /// Overridden. See <see cref="PNode.Paint">PNode.Paint</see>. /// </summary> protected override void Paint(PPaintContext paintContext) { if (image != null) { RectangleF b = Bounds; System.Drawing.Graphics g = paintContext.Graphics; g.DrawImage((Image)image.Clone(), b); if (this is PPathwaySystem) base.Paint(paintContext); } else { base.Paint(paintContext); } }
protected override void Paint(PPaintContext paintContext) { if (Brush != null) { Graphics g = paintContext.Graphics; RectangleF bounds = UnionOfChildrenBounds; bounds = new RectangleF(bounds.X-INDENT,bounds.Y-INDENT,bounds.Width+2*INDENT,bounds.Height+2*INDENT); g.FillRectangle(Brush, bounds); } }
//**************************************************************** // Painting - Methods for painting a PPath. //**************************************************************** /// <summary> /// Overridden. See <see cref="PNode.Paint">PNode.Paint</see>. /// </summary> protected override void Paint(PPaintContext paintContext) { Brush b = this.Brush; Graphics g = paintContext.Graphics; if (b != null) { g.FillPath(b, path); } if (pen != null) { g.DrawPath(pen, path); } }
/// <summary> /// Overridden. See <see cref="PCamera.Paint">PCamera.Paint</see>. /// </summary> protected override void Paint(PPaintContext paintContext) { if (Brush != null) { Device device = (paintContext as P3PaintContext).Device; device.SetStreamSource(0, GetValidVertexBuffer(device), 0); device.VertexFormat = CustomVertex.PositionColored.Format; device.DrawPrimitives(PrimitiveType.TriangleList, VERTEX_INDEX, 2); } PaintTransformedView(paintContext); }
/// <summary> /// Overridden. Paints the cached image representation of this node's children if /// it is not currently being created. /// </summary> /// <param name="paintContext"></param> public override void FullPaint(PPaintContext paintContext) { if (validatingCache) { base.FullPaint (paintContext); } else { Graphics g = paintContext.Graphics; g.DrawImage(ImageCache, (int) X, (int) Y); } }
/// <summary> /// Overridden. See <see cref="PCamera.PaintDebugFullBounds">PaintDebugFullBounds</see>. /// </summary> protected override void PaintDebugFullBounds(PPaintContext paintContext, Brush fullBoundsBrush, RectangleF nodeBounds) { Device device = (paintContext as P3PaintContext).Device; CustomVertex.PositionColored[] colVerts = new CustomVertex.PositionColored[VERTEX_COUNT]; P3Util.CreateColoredRectangle(colVerts, 0, nodeBounds, (fullBoundsBrush as SolidBrush).Color.ToArgb()); device.VertexFormat = CustomVertex.PositionColored.Format; device.DrawUserPrimitives(PrimitiveType.TriangleList, 2, colVerts); }
protected override void Paint(PPaintContext paintContext) { base.Paint (paintContext); ControlPaint.DrawButton(paintContext.Graphics, (int)X, (int)Y, (int)Width, (int)Height, ButtonState.Normal); }