public void DrawGlyphRun(
                Vector2 position,
                CanvasFontFace fontFace,
                float fontSize,
                CanvasGlyph[] glyphs,
                bool isSideways,
                uint bidiLevel,
                object brush,
                CanvasTextMeasuringMode measuringMode,
                string locale,
                string textString,
                int[] clusterMapIndices,
                uint startingTextPosition,
                CanvasGlyphOrientation glyphOrientation)
            {
                if (glyphs == null || glyphs.Length == 0)
                {
                    return;
                }

                float scaledFontAscent               = fontFace.Ascent * fontSize;
                float subscriptBaselineDropAmount    = scaledFontAscent * subscriptBaselineScale;
                float superscriptBaselineRaiseAmount = scaledFontAscent * superscriptBaselineScale;

                // Draw glyph-by-glyph.
                for (int i = 0; i < glyphs.Length; ++i)
                {
                    CanvasGlyph[] singleGlyph = new CanvasGlyph[1];
                    singleGlyph[0] = glyphs[i];

                    Vector2 positionForThisGlyph = position;

                    CustomBrushData brushData = (CustomBrushData)brush;
                    if (brushData != null)
                    {
                        if (brushData.BaselineAdjustment == CustomBrushData.BaselineAdjustmentType.Lower)
                        {
                            positionForThisGlyph.Y += subscriptBaselineDropAmount;
                        }
                        else if (brushData.BaselineAdjustment == CustomBrushData.BaselineAdjustmentType.Raise)
                        {
                            positionForThisGlyph.Y -= superscriptBaselineRaiseAmount;
                        }
                    }

                    DrawingSession.DrawGlyphRun(
                        positionForThisGlyph,
                        fontFace,
                        fontSize,
                        singleGlyph,
                        isSideways,
                        bidiLevel,
                        TextBrush);

                    position.X += glyphs[i].Advance;
                }
            }
Пример #2
0
        public void DrawGlyphRun(Vector2 point, CanvasFontFace fontFace, float fontSize, CanvasGlyph[] glyphs, bool isSideways, uint bidiLevel, object brush, CanvasTextMeasuringMode measuringMode, string localeName, string textString, int[] clusterMapIndices, uint characterIndex, CanvasGlyphOrientation glyphOrientation)
        {
            Matrix3x2 OTrans = ds.Transform;

            int i = 0;

            if (characterIndex == 0)
            {
                ds.Transform = Matrix3x2.CreateTranslation(new Vector2(-0.5f * PTextW, -R)) * Matrix3x2.CreateRotation(Offset, Origin);
                ds.DrawGlyphRun(Origin, fontFace, fontSize, new CanvasGlyph[] { glyphs[0] }, isSideways, bidiLevel, Brush);

                MovingRad = 0;
                i++;
            }

            while (i < glyphs.Length)
            {
                float TextW     = TextWidths[i + characterIndex];
                float Rad       = TextW / R;
                float OffsetRad = 0.5f * (PTextW + TextW) / R + MovingRad;

                MovingRad += Rad;

                // Stop drawing texts if ring is already crowded
                if (6.2831f < (OffsetRad + Rad))
                {
                    break;
                }

                ds.Transform = Matrix3x2.CreateTranslation(new Vector2(-0.5f * TextW, -R)) * Matrix3x2.CreateRotation(OffsetRad + Offset, Origin);
                ds.DrawGlyphRun(Origin, fontFace, fontSize, new CanvasGlyph[] { glyphs[i] }, isSideways, bidiLevel, Brush);

                i++;
            }

            ds.Transform = OTrans;
        }
Пример #3
0
        public void DrawGlyphRun(Vector2 point, CanvasFontFace fontFace, float fontSize, CanvasGlyph[] glyphs, bool isSideways, uint bidiLevel, object brush, CanvasTextMeasuringMode measuringMode, string localeName, string textString, int[] clusterMapIndices, uint characterIndex, CanvasGlyphOrientation glyphOrientation)
        {
            if (points == null)
            {
                Vector2 adv = Vector2.Zero;

                for (int it = 0; it < glyphs.Length; it++)
                {
                    var previousTransform = drawingSession.Transform;
                    var drawPoint         = point + adv;
                    var rotationPoint     = point + adv + new Vector2(glyphs[it].Advance / 2f, -fontSize / 4f);

                    drawingSession.Transform = Matrix3x2.CreateRotation(it * 0.01f, rotationPoint);
                    drawingSession.DrawCircle(point + adv + rotationPoint, 0.022f, Colors.Red);
                    drawingSession.DrawGlyphRun(
                        drawPoint,
                        fontFace,
                        fontSize,
                        new CanvasGlyph[] { glyphs[it] },
                        isSideways,
                        bidiLevel,
                        defaultBrush);
                    drawingSession.Transform = previousTransform;
                    adv += new Vector2(glyphs[it].Advance * Spacing, 0);
                }
            }
            else
            {
                float textLength = 0;
                foreach (var g in glyphs)
                {
                    textLength += g.Advance;
                }
                if (textLength * 3f > dists.Last())
                {
                    return;
                }


                var labelCount = MathF.Truncate(dists.Last() / (textLength * 3));
                labelCount = MathF.Truncate(MathF.Min(labelCount, MathF.Sqrt(labelCount)));
                var labelSegmentLength = dists.Last() / labelCount;

                // DEBUG
                //CanvasPathBuilder path = new CanvasPathBuilder(drawingSession);
                //path.BeginFigure(points[0]);
                //points.ToList().ForEach(p => path.AddLine(p));
                //path.EndFigure(CanvasFigureLoop.Open);
                //drawingSession.DrawGeometry(CanvasGeometry.CreatePath(path), Colors.Blue, 0.1f);
                // =====



                for (int label = 0; label < labelCount; label++)
                {
                    LinearPosition = labelSegmentLength * label + (labelSegmentLength / 2f) - (textLength / 2f);

                    Vector2 adv = Vector2.Zero;

                    for (int it = 0; it < glyphs.Length; it++)
                    {
                        var online = PositionAngleOnPoly(adv.X);

                        var drawPoint = online.pos;
                        var c         = fontSize / 4f;
                        var ox        = MathF.Cos(online.a + MathF.PI / 2f) * c;
                        var oy        = MathF.Sin(online.a + MathF.PI / 2f) * c;
                        drawPoint += new Vector2(ox, oy);

                        var rotationPoint = drawPoint;                        // + new Vector2(glyphs[it].Advance / 2f, -fontSize / 4f);

                        //drawingSession.DrawCircle(rotationPoint, 0.022f, Colors.Red);

                        var previousTransform = drawingSession.Transform;
                        drawingSession.Transform = Matrix3x2.CreateRotation(online.a, rotationPoint);
                        drawingSession.DrawGlyphRun(
                            drawPoint,
                            fontFace,
                            fontSize,
                            new CanvasGlyph[] { glyphs[it] },
                            isSideways,
                            bidiLevel,
                            defaultBrush);
                        drawingSession.Transform = previousTransform;
                        adv += new Vector2(glyphs[it].Advance * Spacing, 0);
                    }
                }
            }

            //drawingSession.DrawGlyphRun(point, fontFace, fontSize, glyphs, isSideways, bidiLevel, defaultBrush);
        }