C# Context.FillPolygonal方法代码示例

        private void DrawTriangles(Context g)
        {
            int px, py;
            Gdk.ModifierType mask;
            GdkWindow.GetPointer (out px, out py, out mask);

            Rectangle rect = GradientRectangle;
            Rectangle all = Allocation.ToCairoRectangle();

            int index = FindValueIndex (py);

            for (int i = 0; i < Count; i++) {

                double val = vals [i];
                double y = GetYFromValue (val);
                bool hoover = ((index == i)) && (all.ContainsPoint (px, py) || ValueIndex != -1);
                Color color = hoover ? new Color (0.1, 0.1, 0.9) : new Color (0.1, 0.1, 0.1);

                //left triangle
                PointD[] points = new PointD[] { new PointD (rect.X, y),
                                                 new PointD (rect.X - xpad * rect.Width, y + ypad * rect.Height),
                                                 new PointD (rect.X - xpad * rect.Width, y - ypad * rect.Height) };
                g.FillPolygonal (points, color);

                double x = rect.X + rect.Width;
                //right triangle
                PointD[] points2 = new PointD[] { new PointD (x , y),
                                                  new PointD (x + xpad * rect.Width, y + ypad * rect.Height),
                                                  new PointD (x + xpad * rect.Width, y - ypad * rect.Height) };
                g.FillPolygonal (points2, color);
            }
        }

		protected Rectangle DrawShape(ShapeEngine engine, Layer l, bool drawCP, bool drawHoverSelection)
		{
			Document doc = PintaCore.Workspace.ActiveDocument;

			Rectangle? dirty = null;

			ShapeEngine activeEngine = ActiveShapeEngine;

			if (activeEngine != null)
			{
				using (Context g = new Context(l.Surface))
				{
					g.AppendPath(doc.Selection.SelectionPath);
					g.FillRule = FillRule.EvenOdd;
					g.Clip();

					g.Antialias = activeEngine.AntiAliasing ? Antialias.Subpixel : Antialias.None;

					g.SetDash(DashPatternBox.GenerateDashArray(activeEngine.DashPattern, activeEngine.BrushWidth), 0.0);

					g.LineWidth = activeEngine.BrushWidth;

					//Draw the shape.
					if (activeEngine.ControlPoints.Count > 0)
					{
						//Generate the points that make up the shape.
						activeEngine.GeneratePoints(activeEngine.BrushWidth);

                        PointD[] points = activeEngine.GetActualPoints ();

						//Expand the invalidation rectangle as necessary.

						if (FillShape)
						{
                            Color fill_color = StrokeShape ? activeEngine.FillColor : activeEngine.OutlineColor;
                            dirty = dirty.UnionRectangles (g.FillPolygonal (points, fill_color));
						}

						if (StrokeShape)
						{
							dirty = dirty.UnionRectangles(g.DrawPolygonal(points, activeEngine.OutlineColor));
						}
					}

					g.SetDash(new double[] { }, 0.0);

					//Draw anything extra (that not every shape has), like arrows.
					DrawExtras(ref dirty, g, engine);

					if (drawCP)
					{
						DrawControlPoints(g, drawHoverSelection);
					}
				}
			}


			return dirty ?? new Rectangle(0d, 0d, 0d, 0d);
		}

        private void DrawChannel(Context g, ColorBgra color, int channel, long max, float mean)
        {
            Rectangle rect = Allocation.ToCairoRectangle ();
            Histogram histogram = Histogram;

            int l = (int)rect.X;
            int t = (int)rect.Y;
            int r = (int)(rect.X + rect.Width);
            int b = (int)(rect.Y + rect.Height);

            int entries = histogram.Entries;
            long[] hist = histogram.HistogramValues [channel];

            ++max;

            if (FlipHorizontal) {
                Utility.Swap(ref l, ref r);
            }

            if (!FlipVertical) {
                Utility.Swap(ref t, ref b);
            }

            PointD[] points = new PointD[entries + 2];

            points[entries] = new PointD (Utility.Lerp (l, r, -1), Utility.Lerp (t, b, 20));
            points[entries + 1] = new PointD (Utility.Lerp (l, r, -1), Utility.Lerp (b, t, 20));

            for (int i = 0; i < entries; i += entries - 1) {
                points[i] = new PointD (
                    Utility.Lerp (l, r, (float)hist[i] / (float)max),
                    Utility.Lerp (t, b, (float)i / (float)entries));

                CheckPoint (rect, points [i]);
            }

            long sum3 = hist[0] + hist[1];

            for (int i = 1; i < entries - 1; ++i) {
                sum3 += hist[i + 1];

                points[i] = new PointD(
                    Utility.Lerp(l, r, (float)(sum3) / (float)(max * 3.1f)),
                    Utility.Lerp(t, b, (float)i / (float)entries));

                CheckPoint (rect, points [i]);
                sum3 -= hist[i - 1];
            }

            byte intensity = selected[channel] ? (byte)96 : (byte)32;
            ColorBgra pen_color = ColorBgra.Blend (ColorBgra.Black, color, intensity);
            ColorBgra brush_color = color;
               	brush_color.A = intensity;

            g.LineWidth = 1;

            g.Rectangle (rect);
            g.Clip ();
            g.DrawPolygonal (points, pen_color.ToCairoColor ());
            g.FillPolygonal (points, brush_color.ToCairoColor ());
        }

		/// <summary>
		/// Draws the arrow.
		/// </summary>
		/// <param name="g">The drawing context.</param>
		/// <param name="endPoint">The end point of a shape.</param>
		/// <param name="almostEndPoint">The point right before the end point.</param>
		public Rectangle? Draw(Context g, Color outlineColor, PointD endPoint, PointD almostEndPoint)
		{
			//First, calculate the ending angle.
			double endingAngle = Math.Atan(Math.Abs(endPoint.Y - almostEndPoint.Y) / Math.Abs(endPoint.X - almostEndPoint.X)) * invRadiansToDegrees;

			//This is necessary to have a properly calculated ending angle.
			if (endPoint.Y - almostEndPoint.Y > 0)
			{
				if (endPoint.X - almostEndPoint.X > 0)
				{
					endingAngle = 180d - endingAngle;
				}
			}
			else
			{
				if (endPoint.X - almostEndPoint.X > 0)
				{
					endingAngle += 180d;
				}
				else
				{
					endingAngle = 360d - endingAngle;
				}
			}

			//Calculate the points of the arrow.
			PointD[] arrowPoints =
							{
								endPoint,
								new PointD(
									endPoint.X + Math.Cos((endingAngle + 270 + AngleOffset) * radiansToDegrees) * ArrowSize,
									endPoint.Y + Math.Sin((endingAngle + 270 + AngleOffset) * radiansToDegrees) * ArrowSize * -1d),
								new PointD(
									endPoint.X + Math.Cos((endingAngle + 180) * radiansToDegrees) * (ArrowSize + LengthOffset),
									endPoint.Y + Math.Sin((endingAngle + 180) * radiansToDegrees) * (ArrowSize + LengthOffset) * -1d),
								new PointD(
									endPoint.X + Math.Cos((endingAngle + 90 - AngleOffset) * radiansToDegrees) * ArrowSize,
									endPoint.Y + Math.Sin((endingAngle + 90 - AngleOffset) * radiansToDegrees) * ArrowSize * -1d)
							};

			//Draw the arrow.
			g.FillPolygonal(arrowPoints, outlineColor);


            //Calculate the minimum bounding rectangle for the arrowhead and return it so
            //that it can be unioned with the existing invalidation rectangle.

			double minX = Math.Min(Math.Min(arrowPoints[1].X, arrowPoints[2].X), arrowPoints[3].X);
			double minY = Math.Min(Math.Min(arrowPoints[1].Y, arrowPoints[2].Y), arrowPoints[3].Y);

			return new Rectangle(minX, minY,
				Math.Max(Math.Max(arrowPoints[1].X, arrowPoints[2].X), arrowPoints[3].X) - minX,
				Math.Max(Math.Max(arrowPoints[1].Y, arrowPoints[2].Y), arrowPoints[3].Y) - minY);
		}