private void DrawVerticalComponent(int index, Graphics g, LiveSplitState state, float width, float height, Region clipRegion) { var component = VisibleComponents.ElementAt(index); var topPadding = Math.Min(GetPaddingAbove(index), component.PaddingTop) / 2f; var bottomPadding = Math.Min(GetPaddingBelow(index), component.PaddingBottom) / 2f; g.IntersectClip(new RectangleF(0, topPadding, width, component.VerticalHeight - topPadding - bottomPadding)); var scale = g.Transform.Elements.First(); var separatorOffset = component.VerticalHeight * scale < 3 ? 1 : 0; if (clipRegion.IsVisible(new RectangleF( g.Transform.OffsetX, -separatorOffset + g.Transform.OffsetY - topPadding * scale, width, separatorOffset * 2f + scale * (component.VerticalHeight + bottomPadding)))) component.DrawVertical(g, state, width, clipRegion); g.TranslateTransform(0.0f, component.VerticalHeight - bottomPadding * 2f); }
private void DrawHorizontalComponent(int index, Graphics g, LiveSplitState state, float width, float height, Region clipRegion) { var component = VisibleComponents.ElementAt(index); var leftPadding = Math.Min(GetPaddingToLeft(index), component.PaddingLeft) / 2f; var rightPadding = Math.Min(GetPaddingToRight(index), component.PaddingRight) / 2f; g.IntersectClip(new RectangleF(leftPadding, 0, component.HorizontalWidth - leftPadding - rightPadding, height)); var scale = g.Transform.Elements.First(); var separatorOffset = component.VerticalHeight * scale < 3 ? 1 : 0; if (clipRegion.IsVisible(new RectangleF( -separatorOffset + g.Transform.OffsetX - leftPadding * scale, g.Transform.OffsetY, separatorOffset * 2f + scale * (component.HorizontalWidth + rightPadding), height))) component.DrawHorizontal(g, state, height, clipRegion); g.TranslateTransform(component.HorizontalWidth - rightPadding * 2f, 0.0f); }
private void PaintLink(Graphics g, Link link, SolidBrush foreBrush, SolidBrush linkBrush, bool optimizeBackgroundRendering, RectangleF finalrect) { // link = null means paint the whole text Debug.Assert(g != null, "Must pass valid graphics"); Debug.Assert(foreBrush != null, "Must pass valid foreBrush"); Debug.Assert(linkBrush != null, "Must pass valid linkBrush"); Font font = Font; if (link != null) { if (link.VisualRegion != null) { Color brushColor = Color.Empty; LinkState linkState = link.State; if ((linkState & LinkState.Hover) == LinkState.Hover) { font = hoverLinkFont; } else { font = linkFont; } if (link.Enabled) { // Not to be confused with Control.Enabled. if ((linkState & LinkState.Active) == LinkState.Active) { brushColor = ActiveLinkColor; } else if ((linkState & LinkState.Visited) == LinkState.Visited) { brushColor = VisitedLinkColor; } // else use linkBrush } else { brushColor = DisabledLinkColor; } if (IsOneLink()) { g.Clip = new Region(finalrect); } else { g.Clip = link.VisualRegion; } if (optimizeBackgroundRendering) { PaintLinkBackground(g); } if( UseCompatibleTextRendering ){ SolidBrush useBrush = brushColor == Color.Empty ? linkBrush : new SolidBrush( brushColor ); StringFormat stringFormat = CreateStringFormat(); g.DrawString(Text, font, useBrush, ClientRectWithPadding, stringFormat); if( useBrush != linkBrush ){ useBrush.Dispose(); } } else{ if(brushColor == Color.Empty ){ brushColor = linkBrush.Color; } IntPtr hdc = g.GetHdc(); try{ using( WindowsGraphics wg = WindowsGraphics.FromHdc( hdc ) ) { brushColor = wg.GetNearestColor(brushColor); } } finally{ g.ReleaseHdc(); } Rectangle clientRectWithPadding = ClientRectWithPadding; TextRenderer.DrawText(g, Text, font, clientRectWithPadding, brushColor, CreateTextFormatFlags(clientRectWithPadding.Size)); } if (Focused && ShowFocusCues && FocusLink == link) { // Get the rectangles making up the visual region, and draw // each one. RectangleF[] rects = link.VisualRegion.GetRegionScans(g.Transform); if( rects != null && rects.Length > 0 ){ Rectangle focusRect; if (IsOneLink()) { //draw one merged focus rectangle focusRect = Rectangle.Ceiling(finalrect); Debug.Assert(finalrect != RectangleF.Empty, "finalrect should be initialized"); ControlPaint.DrawFocusRectangle(g, focusRect, ForeColor, BackColor); } else { foreach (RectangleF rect in rects) { ControlPaint.DrawFocusRectangle(g, Rectangle.Ceiling(rect), ForeColor, BackColor); } } } } } // no else clause... we don't paint anything if we are given a link with no visual region. // } else { // Painting with no link. g.IntersectClip(this.textRegion); if (optimizeBackgroundRendering) { PaintLinkBackground(g); } if( UseCompatibleTextRendering ){ StringFormat stringFormat = CreateStringFormat(); g.DrawString(Text, font, foreBrush, ClientRectWithPadding, stringFormat); } else{ Color color; IntPtr hdc = g.GetHdc(); try{ using( WindowsGraphics wg = WindowsGraphics.FromHdc( hdc ) ) { color = wg.GetNearestColor(foreBrush.Color); } } finally{ g.ReleaseHdc(); } Rectangle clientRectWithPadding = ClientRectWithPadding; TextRenderer.DrawText(g, Text, font, clientRectWithPadding, color, CreateTextFormatFlags(clientRectWithPadding.Size)); } } }
private static void DrawInk(GraphicsPath p, InkPressureFeedbackMode m, Size s, Graphics g) { RectangleF PathBounds = p.GetBounds(); //get the bounds of the path and compute the square scale transform float ds = 0.8f * Math.Min(s.Width / PathBounds.Width, s.Height / PathBounds.Height); GraphicsState OriginalGraphicsState = g.Save(); g.TranslateTransform(s.Width >> 1, s.Height >> 1); g.ScaleTransform(ds, -ds); switch (m) { case InkPressureFeedbackMode.Size: g.FillEllipse(Brushes.Black, new Rectangle(-800, -800, 1600, 1600)); break; case InkPressureFeedbackMode.Width: g.DrawLine(new Pen(Color.Black, 500f), new Point(-500, 0), new Point(500, 0)); break; case InkPressureFeedbackMode.None: case InkPressureFeedbackMode.Color: default: GraphicsPath InkRegion = new GraphicsPath(); //upper-left triangular clip region to fake "ink" InkRegion.AddPolygon(new Point[] { Point.Empty, new Point(s.Width, 0), new Point(0, s.Height) }); Matrix InverseTransform = g.Transform; InverseTransform.Invert(); InkRegion.Transform(InverseTransform); g.IntersectClip(new Region(InkRegion)); g.DrawPath(new Pen(Color.Blue, 4 / ds), p); break; } g.Restore(OriginalGraphicsState); }
partial void IntersectClipImp(RectangleF r) { g.IntersectClip(r.ToSystemDrawingObject()); }
void RenderControls(Graphics g) { g.IntersectClip(GetDesignRect()); g.Clear(this.BackColor); int x = _model.PageWidth; g.DrawLine(Pens.WhiteSmoke,PointToDesignScreen(new Point(x,0)),PointToDesignScreen(new Point(x,this.Height))); foreach (Band band in _model.Bands) { if (band.Row >= _top) { foreach (BaseWidget widget in band.Items) { Point p = PointToDesignScreen(new Point(widget.Col,widget.Row)); Brush brush = new SolidBrush(Color.FromKnownColor(KnownColor.WindowText)); Font font; FontStyle fontStyle = FontStyle.Regular; //if (widget.IsSelected) //{ // font = _italicFont; //} //else //{ // font = _normalFont; //} if (widget.IsBold) fontStyle |= FontStyle.Bold; if (widget.IsUnderline) fontStyle |= FontStyle.Underline; if (widget.IsItalic) fontStyle |= FontStyle.Italic; font = new Font("Courier New",10, fontStyle); if (widget.IsSelected) { g.FillRectangle(new SolidBrush(Color.FromKnownColor(KnownColor.Highlight)), RectToScreen(widget.GetRectangle())); brush = new SolidBrush(Color.FromKnownColor(KnownColor.HighlightText)); } else if (widget is ValueWidget) { g.FillRectangle(new SolidBrush(Color.FromKnownColor(KnownColor.Control)), RectToScreen(widget.GetRectangle())); brush = new SolidBrush(Color.FromKnownColor(KnownColor.ControlText)); } DrawString(g, font, brush, widget.ToString(), p.X, p.Y); brush.Dispose(); font.Dispose(); } } } }
/// <summary> /// Render this object to the specified <see cref="Graphics"/> device /// This method is normally only called by the Draw method /// of the parent <see cref="GraphObjList"/> collection object. /// </summary> /// <param name="g"> /// A graphic device object to be drawn into. This is normally e.Graphics from the /// PaintEventArgs argument to the Paint() method. /// </param> /// <param name="pane"> /// A reference to the <see cref="PaneBase"/> object that is the parent or /// owner of this object. /// </param> /// <param name="scaleFactor"> /// The scaling factor to be used for rendering objects. This is calculated and /// passed down by the parent <see cref="GraphPane"/> object using the /// <see cref="PaneBase.CalcScaleFactor"/> method, and is used to proportionally adjust /// font sizes, etc. according to the actual size of the graph. /// </param> override public void Draw( Graphics g, PaneBase pane, float scaleFactor ) { if ( _image != null ) { // Convert the rectangle coordinates from the user coordinate system // to the screen coordinate system RectangleF tmpRect = _location.TransformRect( pane ); if ( _isScaled ) g.DrawImage( _image, tmpRect ); else { Region clip = g.Clip.Clone(); g.IntersectClip( tmpRect ); g.DrawImageUnscaled( _image, Rectangle.Round( tmpRect ) ); g.Clip = clip; //g.DrawImageUnscaledAndClipped( image, Rectangle.Round( tmpRect ) ); } } }
/// <summary> /// Draws string into specified rectangle using given ParagraphFormat. /// </summary> /// <param name="gr"></param> /// <param name="rect"></param> /// <param name="pf"></param> /// <remarks> /// This is the 'main' method of the class. This one is called by StringDrawUtils /// to draw formatted string.<br/> /// As this class (and consequently this method) isn't to be published, there are some limitations:<br/> /// Angle of InitialFormat (specified at construction) has to be zero.<br/> /// BackgroundBrush /// </remarks> public void DrawStringInRectangle(Graphics gr, RectangleF rect, ParagraphFormat pf) { Debug.Assert(InitialFormat.Angle==0); Debug.Assert(pf.BackgroundBrush==null); if(pf.VerticalAlignment!=ParagraphVerticalAlignment.Top) { int lines=Math.Min(GetMaxVisibleLineCount(gr, rect.Height, pf), CountOf(Interval.Full(this), '\n')+1); float lineHeight=sdu.GetLineHeight(gr,InitialFormat.Font); float totalHeight=(lineHeight*lines)+ sdu.GetMeasureStringVerticalGap(gr, InitialFormat.Font); switch(pf.VerticalAlignment) { case ParagraphVerticalAlignment.Bottom: rect.Offset(0, rect.Height-totalHeight); break; case ParagraphVerticalAlignment.Center: rect.Offset(0, (rect.Height-totalHeight)/2); break; } } Region oldClip=gr.Clip.Clone(); gr.IntersectClip(rect); DrawStringLineByLine(gr, rect, pf); gr.Clip=oldClip; }
private void PaintLink(Graphics g, Link link, SolidBrush foreBrush, SolidBrush linkBrush, bool optimizeBackgroundRendering, RectangleF finalrect) { Font hoverLinkFont = this.Font; if (link != null) { if (link.VisualRegion != null) { Color empty = Color.Empty; LinkState state = link.State; if ((state & LinkState.Hover) == LinkState.Hover) { hoverLinkFont = this.hoverLinkFont; } else { hoverLinkFont = this.linkFont; } if (link.Enabled) { if ((state & LinkState.Active) == LinkState.Active) { empty = this.ActiveLinkColor; } else if ((state & LinkState.Visited) == LinkState.Visited) { empty = this.VisitedLinkColor; } } else { empty = this.DisabledLinkColor; } if (this.IsOneLink()) { g.Clip = new Region(finalrect); } else { g.Clip = link.VisualRegion; } if (optimizeBackgroundRendering) { this.PaintLinkBackground(g); } if (this.UseCompatibleTextRendering) { SolidBrush brush = (empty == Color.Empty) ? linkBrush : new SolidBrush(empty); StringFormat format = this.CreateStringFormat(); g.DrawString(this.Text, hoverLinkFont, brush, this.ClientRectWithPadding, format); if (brush != linkBrush) { brush.Dispose(); } } else { if (empty == Color.Empty) { empty = linkBrush.Color; } IntPtr hdc = g.GetHdc(); try { using (WindowsGraphics graphics = WindowsGraphics.FromHdc(hdc)) { empty = graphics.GetNearestColor(empty); } } finally { g.ReleaseHdc(); } Rectangle clientRectWithPadding = this.ClientRectWithPadding; TextRenderer.DrawText(g, this.Text, hoverLinkFont, clientRectWithPadding, empty, this.CreateTextFormatFlags(clientRectWithPadding.Size)); } if ((this.Focused && this.ShowFocusCues) && (this.FocusLink == link)) { RectangleF[] regionScans = link.VisualRegion.GetRegionScans(g.Transform); if ((regionScans != null) && (regionScans.Length > 0)) { if (this.IsOneLink()) { Rectangle rectangle = Rectangle.Ceiling(finalrect); ControlPaint.DrawFocusRectangle(g, rectangle, this.ForeColor, this.BackColor); } else { foreach (RectangleF ef in regionScans) { ControlPaint.DrawFocusRectangle(g, Rectangle.Ceiling(ef), this.ForeColor, this.BackColor); } } } } } } else { g.IntersectClip(this.textRegion); if (optimizeBackgroundRendering) { this.PaintLinkBackground(g); } if (this.UseCompatibleTextRendering) { StringFormat format2 = this.CreateStringFormat(); g.DrawString(this.Text, hoverLinkFont, foreBrush, this.ClientRectWithPadding, format2); } else { Color nearestColor; IntPtr hDc = g.GetHdc(); try { using (WindowsGraphics graphics2 = WindowsGraphics.FromHdc(hDc)) { nearestColor = graphics2.GetNearestColor(foreBrush.Color); } } finally { g.ReleaseHdc(); } Rectangle bounds = this.ClientRectWithPadding; TextRenderer.DrawText(g, this.Text, hoverLinkFont, bounds, nearestColor, this.CreateTextFormatFlags(bounds.Size)); } } }
/// <summary> /// Draw the this <see cref="CurveItem"/> to the specified <see cref="Graphics"/> /// device using the specified smoothing property (<see cref="ZedGraph.Line.SmoothTension"/>). /// The routine draws the line segments and the area fill (if any, see <see cref="FillType"/>; /// the symbols are drawn by the <see cref="Symbol.Draw"/> method. This method /// is normally only called by the Draw method of the /// <see cref="CurveItem"/> object. Note that the <see cref="StepType"/> property /// is ignored for smooth lines (e.g., when <see cref="ZedGraph.Line.IsSmooth"/> is true). /// </summary> /// <param name="g"> /// A graphic device object to be drawn into. This is normally e.Graphics from the /// PaintEventArgs argument to the Paint() method. /// </param> /// <param name="scaleFactor"> /// The scaling factor to be used for rendering objects. This is calculated and /// passed down by the parent <see cref="GraphPane"/> object using the /// <see cref="PaneBase.CalcScaleFactor"/> method, and is used to proportionally adjust /// font sizes, etc. according to the actual size of the graph. /// </param> /// <param name="pane"> /// A reference to the <see cref="GraphPane"/> object that is the parent or /// owner of this object. /// </param> /// <param name="curve">A <see cref="LineItem"/> representing this /// curve.</param> public void DrawSmoothFilledCurve( Graphics g, GraphPane pane, CurveItem curve, float scaleFactor ) { Line source = this; if ( curve.IsSelected ) source = Selection.Line; PointF[] arrPoints; int count; IPointList points = curve.Points; if ( this.IsVisible && !this.Color.IsEmpty && points != null && BuildPointsArray( pane, curve, out arrPoints, out count ) && count > 2 ) { float tension = _isSmooth ? _smoothTension : 0f; // Fill the curve if needed if ( this.Fill.IsVisible ) { Axis yAxis = curve.GetYAxis( pane ); using ( GraphicsPath path = new GraphicsPath( FillMode.Winding ) ) { path.AddCurve( arrPoints, 0, count - 2, tension ); double yMin = yAxis._scale._min < 0 ? 0.0 : yAxis._scale._min; CloseCurve( pane, curve, arrPoints, count, yMin, path ); RectangleF rect = path.GetBounds(); using ( Brush brush = source._fill.MakeBrush( rect ) ) { if ( pane.LineType == LineType.Stack && yAxis.Scale._min < 0 && this.IsFirstLine( pane, curve ) ) { float zeroPix = yAxis.Scale.Transform( 0 ); RectangleF tRect = pane.Chart._rect; tRect.Height = zeroPix - tRect.Top; if ( tRect.Height > 0 ) { Region reg = g.Clip.Clone(); g.IntersectClip( tRect ); g.FillPath( brush, path ); g.Clip = reg; } } else g.FillPath( brush, path ); //brush.Dispose(); } // restore the zero line if needed (since the fill tends to cover it up) yAxis.FixZeroLine( g, pane, scaleFactor, rect.Left, rect.Right ); } } // If it's a smooth curve, go ahead and render the path. Otherwise, use the // standard drawcurve method just in case there are missing values. if ( _isSmooth ) { using ( Pen pen = GetPen( pane, scaleFactor ) ) { // Stroke the curve g.DrawCurve( pen, arrPoints, 0, count - 2, tension ); //pen.Dispose(); } } else DrawCurve( g, pane, curve, scaleFactor ); } }
public void IntersectClipRectangle(Graphics g) { Pen myPen = new Pen(Color.FromArgb(255, 0, 0x33, 0), (float)0.6); SolidBrush myBrush = new SolidBrush(Color.FromArgb(127, 0x66, 0xEF, 0x7F)); // Set clipping region. Rectangle clipRect = new Rectangle(0, 0, 200, 200); Region clipRegion = new Region(clipRect); g.SetClip(clipRegion, CombineMode.Replace); // Update clipping region to intersection of // existing region with specified rectangle. Rectangle intersectRect = new Rectangle(100, 100, 200, 200); Region intersectRegion = new Region(intersectRect); g.IntersectClip(intersectRegion); // Fill rectangle to demonstrate effective clipping region. g.FillRectangle(myBrush, 0, 0, 500, 500); // Reset clipping region to infinite. g.ResetClip(); // Draw clipRect and intersectRect to screen. myPen.Color = Color.FromArgb(196, 0xC3, 0xC9, 0xCF); myBrush.Color = Color.FromArgb(127, 0xDD, 0xDD, 0xF0); g.DrawRectangle(myPen, clipRect); g.FillRectangle(myBrush, clipRect); myPen.Color = Color.FromArgb(196, 0xF9, 0xBE, 0xA6); myBrush.Color = Color.FromArgb(127, 0xFF, 0xE0, 0xE0); g.DrawRectangle(myPen, intersectRect); g.FillRectangle(myBrush, intersectRect); }
/// <summary> /// Draws full aligned string into given rectangle. /// </summary> /// <param name="gr"><see cref="Graphics"/> object to draw into.</param> /// <param name="str"><see cref="string"/> to be drawn.</param> /// <param name="rect"><see cref="Rectangle"/> that string is drawn into.</param> /// <param name="cf"><see cref="CharacterFormat"/> used to draw the <paramref name="str"/>. </param> /// <param name="pf"><see cref="ParagraphFormat"/> used to draw the <paramref name="str"/>. </param> /// <remarks>As this method isn't to be exposed as public, there are /// several limitations:<br/> /// <see cref="Rectangle.Width"/> has to be non-zero.<br/> /// <see cref="CharacterFormat.Angle"/> has to be zero.<br/> /// <see cref="ParagraphFormat.MultiLine"/> has to be false.<br/> /// <see cref="ParagraphFormat.Alignment"/> has to be <see cref="ParagraphAlignment.Full"/>.<br/> /// <see cref="ParagraphFormat.BackgroundBrush"/> has to be null.<br/> /// If not satisfied, results might be not as expected.</remarks> private void DrawFullAlignedStringInRectangle(Graphics gr, string str, RectangleF rect, CharacterFormat cf, ParagraphFormat pf) { Region oldClip = gr.Clip.Clone(); gr.IntersectClip(rect); float yofs = rect.Y; StringFormat sfLeft; //StringFormat for drawing left-aligned lines { ParagraphFormat pf2 = pf.ShallowCopy(); pf2.Alignment = ParagraphAlignment.Left; pf2.VerticalAlignment = ParagraphVerticalAlignment.Top; pf2.MultiLine = false; pf2.ShowIncompleteLines = true; sfLeft = GetStringFormat(cf, pf2); } //lineHeight & borders retrieving float lineHeight = GetLineHeight(gr, cf.Font); int lineCount; //lineCount retrieving { StringFormat sf = GetStringFormat(cf, pf); int charfit; gr.MeasureString(str, cf.Font, new SizeF(rect.Width, rect.Height), sf, out charfit, out lineCount); } //VerticalAlignment business switch (pf.VerticalAlignment) { case ParagraphVerticalAlignment.Bottom: yofs += rect.Height - lineHeight*lineCount; break; case ParagraphVerticalAlignment.Center: yofs += (rect.Height - lineHeight*lineCount)/2; break; } int flc = 0; //first line character int llc = flc; //last line character (actually the one after last) int lineIndex = 0; while (lineIndex < lineCount - 1 && flc < str.Length) { lineIndex++; llc = flc; //add spaces at the beginneing while (llc < str.Length && Char.IsWhiteSpace(str, llc)) llc++; //add words until the line is full int pllc = llc; //potential last line character while (llc == pllc && llc < str.Length) { pllc++; while (pllc < str.Length && !Char.IsWhiteSpace(str, pllc)) pllc++; if (gr.MeasureString(str.Substring(flc, pllc - flc), cf.Font).Width < rect.Width) llc = pllc; } //If nothing was added before, add single characters (rect.Width is too small) if (llc == flc) do { //always at least one character per line llc++; } while (llc < str.Length && gr.MeasureString(str.Substring(flc, llc - flc + 1), cf.Font).Width < rect.Width); string line = str.Substring(flc, llc - flc); //Newline fotmatting int nlindex = line.IndexOf('\n'); if (nlindex >= 0) { //Newline may be just "\n" or "\r\n" if (nlindex > 1 && line[nlindex - 1] == '\r') line = line.Substring(0, nlindex - 1); else line = line.Substring(0, nlindex); DrawString(gr, line, new PointF(rect.X, yofs), cf); flc += nlindex + 1; } else { DrawFullAlignedLine(gr, line, new PointF(rect.X, yofs), rect.Width, cf); flc = llc; //skip spaces at the end of line (just like Graphics.DrawString does) while (flc < str.Length && Char.IsWhiteSpace(str, flc)) flc++; } yofs += lineHeight; } //And here comes the last line - it's always drawn left-aligned //(also, we have to get rid of newlines or they will sometimes show //in the bottom) gr.DrawString(str.Substring(flc), cf.Font, cf.Brush, new RectangleF(rect.X, yofs, rect.Width, lineHeight), sfLeft); //Set back the original clipping region gr.Clip = oldClip; }
protected Region PushClip(Graphics g, RectangleF clip) { var previousClip = g.Clip.Clone(); g.IntersectClip(clip); return previousClip; }
partial void IntersectClipImp(RectangleF r) { g.IntersectClip(r); }