Exemple #1
0
        public void DrawGlyphRun(Brush foreground, GlyphRun glyphRun)
        {
            if (foreground == null)
            {
                return;
            }

            AssertState(DeviceState.PageStarted, DeviceState.NoChange);

            GlyphPrimitive g = new GlyphPrimitive();

            bool needBounds = false;

            if (foreground != null && !(foreground is SolidColorBrush))
            {
                needBounds = true;
            }

            g.GlyphRun    = glyphRun;
            g.Brush       = BrushProxy.CreateBrush(foreground, g.GetRectBounds(needBounds));
            g.Clip        = _clip;
            g.Opacity     = _opacity;
            g.OpacityMask = _opacityMask;

            // Optimization: Unfold primitive DrawingBrush when possible to avoid rasterizing it.
            Primitive primitive = g.UnfoldDrawingBrush();

            if (primitive != null)
            {
                _root.Children.Add(primitive);
            }
        }
Exemple #2
0
        /// <summary>
        /// Resolve overlapping for a single primitive
        /// </summary>
        /// <param name="primitive"></param>
        /// <param name="overlapping"></param>
        /// <param name="overlapHasTransparency"></param>
        /// <param name="disjoint"></param>
        /// <param name="desp"></param>
        private void AlphaRender(Primitive primitive, List <int> overlapping, int overlapHasTransparency, bool disjoint, string desp)
        {
            if (primitive == null)
            {
                return;
            }

            // Skip alpha flattening when there are too many layer of transparency
            if (overlapHasTransparency > Configuration.MaximumTransparencyLayer)
            {
                overlapping = null;
            }

            PrimitiveRenderer ri = new PrimitiveRenderer();

            ri.Clip        = primitive.Clip;
            ri.Brush       = null;
            ri.Pen         = null;
            ri.Overlapping = overlapping;
            ri.Commands    = _dl.Commands;
            ri.DC          = _dc;
            ri.Disjoint    = disjoint;

            GeometryPrimitive p = primitive as GeometryPrimitive;

            if (p != null)
            {
                ri.Brush = p.Brush;
                ri.Pen   = p.Pen;

                bool done = false;

                Geometry g = p.Geometry;

                GlyphPrimitive gp = p as GlyphPrimitive;

                if (gp != null)
                {
                    done = ri.DrawGlyphs(gp.GlyphRun, gp.GetRectBounds(true), p.Transform, desp);

                    if (!done)
                    {
                        g = p.WidenGeometry;
                    }
                }

                if (!done)
                {
                    if (!p.Transform.IsIdentity)
                    {
                        // Should not occur; GeometryPrimitive.ApplyTransform will push transform
                        // to geometry and brush.
                        g = Utility.TransformGeometry(g, p.Transform);

                        if (ri.Brush != null)
                        {
                            ri.Brush = ri.Brush.ApplyTransformCopy(p.Transform);
                        }

                        if (ri.Pen != null && ri.Pen.StrokeBrush != null)
                        {
                            ri.Pen             = ri.Pen.Clone();
                            ri.Pen.StrokeBrush = ri.Pen.StrokeBrush.ApplyTransformCopy(p.Transform);
                        }
                    }

                    ri.DrawGeometry(g, desp, p);
                }

                return;
            }

            ImagePrimitive ip = primitive as ImagePrimitive;

            if (ip != null)
            {
                ri.RenderImage(ip.Image, ip.DstRect, ip.Clip, ip.Transform, desp);
            }
            else
            {
                Debug.Assert(false, "Wrong Primitive type");
            }
        }