Beispiel #1
0
        static CTLine GetLabel(string label, CGColor foregroundColor, out CGSize bounds)
        {
            // I seriously have no idea what this is other than 8388608/1024/1024=8 -abock
            const int undocumentedKennethConstantOnlyHeUnderstands = 8388608;

            var typesetter = new CTTypesetter(
                new NSAttributedString(
                    label,
                    new CTStringAttributes {
                Font            = new CTFont(LabelFontBold.FontName, LabelFontBold.PointSize),
                ForegroundColor = foregroundColor
            }.Dictionary
                    )
                );

            var lineRange = new NSRange(0, typesetter.SuggestLineBreak(0,
                                                                       undocumentedKennethConstantOnlyHeUnderstands));
            var line = typesetter.GetLine(lineRange);

            nfloat ascent;
            nfloat descent;
            nfloat leading;
            var    lineWidth = line.GetTypographicBounds(out ascent, out descent, out leading);

            bounds = new CGSize(
                // +1 matches best to CTFramesetter's behavior
                (nfloat)Math.Ceiling(ascent + descent + leading + 1),
                (nfloat)lineWidth
                );

            return(line);
        }
Beispiel #2
0
        public SizeF MeasureString(string textg, Font font, RectangleF rect)
        {
            // As per documentation
            // https://developer.apple.com/library/mac/#documentation/GraphicsImaging/Conceptual/drawingwithquartz2d/dq_text/dq_text.html#//apple_ref/doc/uid/TP30001066-CH213-TPXREF101
            //
            // * Note * Not sure if we should save off the graphic state, set context transform to identity
            //  and restore state to do the measurement.  Something to be looked into.
            //			context.TextPosition = rect.Location;
            //			var startPos = context.TextPosition;
            //			context.SelectFont ( font.nativeFont.PostScriptName,
            //			                    font.SizeInPoints,
            //			                    CGTextEncoding.MacRoman);
            //			context.SetTextDrawingMode(CGTextDrawingMode.Invisible);
            //
            //			context.SetCharacterSpacing(1);
            //			var textMatrix = CGAffineTransform.MakeScale(1f,-1f);
            //			context.TextMatrix = textMatrix;
            //
            //			context.ShowTextAtPoint(rect.X, rect.Y, textg, textg.Length);
            //			var endPos = context.TextPosition;
            //
            //			var measure = new SizeF(endPos.X - startPos.X, font.nativeFont.CapHeightMetric);

            var atts = buildAttributedString(textg, font);

            var measure = SizeF.Empty;
            // Calculate the lines
            int start  = 0;
            int length = (int)atts.Length;

            var typesetter = new CTTypesetter(atts);

            while (start < length)
            {
                int count = (int)typesetter.SuggestLineBreak(start, 8388608);
                var line  = typesetter.GetLine(new NSRange(start, count));

                // Create and initialize some values from the bounds.
                nfloat ascent;
                nfloat descent;
                nfloat leading;
                var    lineWidth = line.GetTypographicBounds(out ascent, out descent, out leading);

                measure.Height += (float)Math.Ceiling(ascent + descent + leading + 1);                  // +1 matches best to CTFramesetter's behavior
                if (lineWidth > measure.Width)
                {
                    measure.Width = (float)lineWidth;
                }

                line.Dispose();
                start += count;
            }

            return(measure);
        }
        public static XIR.Image RemoteRepresentation(this NSAttributedString attributedString)
        {
            var typesetter = new CTTypesetter(attributedString);
            var measure    = CGSize.Empty;

            var count = typesetter.SuggestLineBreak(0, 8388608);
            var line  = typesetter.GetLine(new NSRange(0, count));

            // Create and initialize some values from the bounds.
            nfloat ascent;
            nfloat descent;
            nfloat leading;
            var    lineWidth = line.GetTypographicBounds(out ascent, out descent, out leading);

            measure.Height += (float)Math.Ceiling(ascent + descent + leading + 1);  // +1 matches best to CTFramesetter's behavior
            measure.Width   = (float)lineWidth;

            var width  = (int)measure.Width > 0 ? (int)measure.Width : 200;
            var height = (int)measure.Height > 0 ? (int)measure.Height : 200;

            var bytesPerRow = width * 4;

            using (var context = new CGBitmapContext(
                       IntPtr.Zero, width, height,
                       8, bytesPerRow, CGColorSpace.CreateDeviceRGB(),
                       CGImageAlphaInfo.PremultipliedFirst))
            {
                context.ConcatCTM(context.GetCTM().Invert());
                var matrix = new CGAffineTransform(
                    1, 0, 0, -1, 0, height);

                context.ConcatCTM(matrix);
                var textMatrix = new CGAffineTransform(
                    1, 0, 0, -1, 0, ascent);

                context.TextMatrix = textMatrix;
                line.Draw(context);
                line.Dispose();

                return(RemoteRepresentation(context));
            }
        }
Beispiel #4
0
        private List <CTLine> CreateLines(Font font, NSAttributedString attributedString, SizeF layoutBox, StringFormat format, float lineHeight)
        {
            bool noWrap     = (format.FormatFlags & StringFormatFlags.NoWrap) != 0;
            bool wholeLines = (format.FormatFlags & StringFormatFlags.LineLimit) != 0;

            using (var typesetter = new CTTypesetter(attributedString))
            {
                var   lines  = new List <CTLine>();
                int   start  = 0;
                int   length = (int)attributedString.Length;
                float y      = 0;
                while (start < length && y < layoutBox.Height && (!wholeLines || y + lineHeight <= layoutBox.Height))
                {
                    if (format.Trimming != StringTrimming.None)
                    {
                        // Keep the last line in full when trimming is enabled
                        bool lastLine;
                        if (!wholeLines)
                        {
                            lastLine = y + lineHeight >= layoutBox.Height;
                        }
                        else
                        {
                            lastLine = y + lineHeight + lineHeight > layoutBox.Height;
                        }
                        if (lastLine)
                        {
                            noWrap = true;
                        }
                    }

                    // Now we ask the typesetter to break off a line for us.
                    // This also will take into account line feeds embedded in the text.
                    //  Example: "This is text \n with a line feed embedded inside it"
                    var count = (int)typesetter.SuggestLineBreak(start, noWrap ? double.MaxValue : layoutBox.Width);

                    // Note: trimming may return a null line i.e. not enough space for any characters
                    var line = typesetter.GetLine(new NSRange(start, count));
                    switch (format.Trimming)
                    {
                    case StringTrimming.Character:
                        using (var oldLine = line)
                            line = line.GetTruncatedLine(noWrap ? nfloat.MaxValue : layoutBox.Width, CTLineTruncation.End, null);
                        break;

                    case StringTrimming.EllipsisWord:                             // Fall thru for now
                    case StringTrimming.EllipsisCharacter:
                        using (var oldLine = line)
                            using (CTLine ellipsisToken = EllipsisToken(font, format))
                                line = line.GetTruncatedLine(layoutBox.Width, CTLineTruncation.End, ellipsisToken);
                        break;

                    case StringTrimming.EllipsisPath:
                        using (var oldLine = line)
                            using (CTLine ellipsisToken = EllipsisToken(font, format))
                                line = line.GetTruncatedLine(layoutBox.Width, CTLineTruncation.Middle, ellipsisToken);
                        break;
                    }

                    lines.Add(line);
                    start += (int)count;
                    y     += (float)lineHeight;
                }
                return(lines);
            }
        }
        internal void NativeDrawString(string s, Font font, Color brush, RectangleF layoutRectangle, StringFormat stringFormat)
        {
            if (font == null)
            {
                throw new ArgumentNullException("font");
            }

            if (s == null || s.Length == 0)
            {
                return;
            }

            var attributedString = buildAttributedString(s, font, brush);

            // Work out the geometry
            RectangleF insetBounds     = layoutRectangle;
            bool       layoutAvailable = true;

            if (insetBounds.Size == SizeF.Empty)
            {
                insetBounds.Size = new SizeF(8388608, 8388608);
                layoutAvailable  = false;
            }

            PointF textPosition = new PointF(insetBounds.X,
                                             insetBounds.Y);

            float boundsWidth = insetBounds.Width;

            // Calculate the lines
            int start  = 0;
            int length = (int)attributedString.Length;

            var typesetter = new CTTypesetter(attributedString);

            float baselineOffset = 0;

            // First we need to calculate the offset for Vertical Alignment if we
            // are using anything but Top
            if (layoutAvailable && stringFormat.LineAlignment != StringAlignment.Near)
            {
                while (start < length)
                {
                    int count = (int)typesetter.SuggestLineBreak(start, boundsWidth);
                    var line  = typesetter.GetLine(new NSRange(start, count));

                    // Create and initialize some values from the bounds.
                    nfloat ascent;
                    nfloat descent;
                    nfloat leading;
                    line.GetTypographicBounds(out ascent, out descent, out leading);
                    baselineOffset += (float)Math.Ceiling(ascent + descent + leading + 1);                      // +1 matches best to CTFramesetter's behavior
                    line.Dispose();
                    start += count;
                }
            }

            start = 0;

            while (start < length && textPosition.Y < insetBounds.Bottom)
            {
                // Now we ask the typesetter to break off a line for us.
                // This also will take into account line feeds embedded in the text.
                //  Example: "This is text \n with a line feed embedded inside it"
                int count = (int)typesetter.SuggestLineBreak(start, boundsWidth);
                var line  = typesetter.GetLine(new NSRange(start, count));

                // Create and initialize some values from the bounds.
                nfloat ascent;
                nfloat descent;
                nfloat leading;
                double lineWidth = line.GetTypographicBounds(out ascent, out descent, out leading);

                if (!layoutAvailable)
                {
                    insetBounds.Width  = (float)lineWidth;
                    insetBounds.Height = (float)(ascent + descent + leading);
                }

                // Calculate the string format if need be
                var penFlushness = 0.0f;

                if (stringFormat.Alignment == StringAlignment.Far)
                {
                    penFlushness = (float)line.GetPenOffsetForFlush(1.0f, insetBounds.Width);
                }
                else if (stringFormat.Alignment == StringAlignment.Center)
                {
                    penFlushness = (float)line.GetPenOffsetForFlush(0.5f, insetBounds.Width);
                }

                // initialize our Text Matrix or we could get trash in here
                var textMatrix = new CGAffineTransform(
                    1, 0, 0, -1, 0, ascent);

                if (stringFormat.LineAlignment == StringAlignment.Near)
                {
                    textMatrix.Translate(penFlushness + textPosition.X, textPosition.Y);                      //insetBounds.Height - textPosition.Y -(float)Math.Floor(ascent - 1));
                }
                if (stringFormat.LineAlignment == StringAlignment.Center)
                {
                    textMatrix.Translate(penFlushness + textPosition.X, textPosition.Y + ((insetBounds.Height / 2) - (baselineOffset / 2)));                        // -(float)Math.Floor(ascent)
                }
                if (stringFormat.LineAlignment == StringAlignment.Far)
                {
                    textMatrix.Translate(penFlushness + textPosition.X, textPosition.Y + ((insetBounds.Height) - (baselineOffset)));
                }

                var glyphRuns = line.GetGlyphRuns();

                for (int glyphRunIndex = 0; glyphRunIndex < glyphRuns.Length; glyphRunIndex++)
                {
                    var glyphRun       = glyphRuns [glyphRunIndex];
                    var glyphs         = glyphRun.GetGlyphs();
                    var glyphPositions = glyphRun.GetPositions();
                    //var textMatrix = glyphRun.TextMatrix;

                    // Create and initialize some values from the bounds.
                    float glyphAscent;
                    float glyphDescent;
                    float glyphLeading;

                    var elementPoints = new PointF [3];

                    for (int glyphIndex = 0; glyphIndex < glyphs.Length; glyphIndex++)
                    {
                        if (glyphIndex > 0)
                        {
                            textMatrix.x0 += glyphPositions [glyphIndex].X - glyphPositions[glyphIndex - 1].X;
                            textMatrix.y0 += glyphPositions [glyphIndex].Y - glyphPositions[glyphIndex - 1].Y;
                        }

                        var glyphPath = font.nativeFont.GetPathForGlyph(glyphs [glyphIndex]);

                        // glyphPath = null if it is a white space character
                        if (glyphPath != null)
                        {
                            glyphPath.Apply(
                                delegate(CGPathElement pathElement) {
                                elementPoints[0] = textMatrix.TransformPoint(pathElement.Point1).ToPointF();
                                elementPoints[1] = textMatrix.TransformPoint(pathElement.Point2).ToPointF();
                                elementPoints[2] = textMatrix.TransformPoint(pathElement.Point3).ToPointF();
                                //Console.WriteLine ("Applying {0} - {1}, {2}, {3}", pathElement.Type, elementPoints[0], elementPoints[1], elementPoints[2]);


                                // now add position offsets
                                switch (pathElement.Type)
                                {
                                case CGPathElementType.MoveToPoint:
                                    start_new_fig = true;
                                    Append(elementPoints[0].X, elementPoints[0].Y, PathPointType.Line, true);
                                    break;

                                case CGPathElementType.AddLineToPoint:
                                    var lastPoint = points[points.Count - 1];
                                    AppendPoint(lastPoint, PathPointType.Line, false);
                                    AppendPoint(elementPoints[0], PathPointType.Line, false);
                                    break;

                                case CGPathElementType.AddCurveToPoint:
                                case CGPathElementType.AddQuadCurveToPoint:
                                    //  This is the only thing I can think of right now for the fonts that
                                    //  I have tested.  See the description of the quadraticToCubic method for
                                    //  more information

                                    // Get the last point
                                    var pt1 = points[points.Count - 1];
                                    var pt2 = PointF.Empty;
                                    var pt3 = PointF.Empty;
                                    var pt4 = elementPoints[1];
                                    GeomUtilities.QuadraticToCubic(pt1, elementPoints[0], elementPoints[1], out pt2, out pt3);
                                    Append(pt1.X, pt1.Y, PathPointType.Line, true);
                                    AppendBezier(pt2.X, pt2.Y, pt3.X, pt3.Y, pt4.X, pt4.Y);
                                    break;

                                case CGPathElementType.CloseSubpath:
                                    CloseFigure();
                                    break;
                                }
                            }

                                );
                        }
                    }
                }

                // Move the index beyond the line break.
                start          += count;
                textPosition.Y += (float)Math.Ceiling(ascent + descent + leading + 1);                 // +1 matches best to CTFramesetter's behavior
                line.Dispose();
            }
        }
Beispiel #6
0
        public void DrawString(string s, Font font, Brush brush, RectangleF layoutRectangle, StringFormat format = null)
        {
            if (font == null)
            {
                throw new ArgumentNullException("font");
            }
            if (brush == null)
            {
                throw new ArgumentNullException("brush");
            }
            if (s == null || s.Length == 0)
            {
                return;
            }

            if (format == null)
            {
                format = StringFormat.GenericDefault;
            }

            // TODO: Take into consideration units

            // Not sure we need the Save and Restore around this yet.
            context.SaveState();

            // TextMatrix is not part of the Graphics State and Restore
            var  saveMatrix      = context.TextMatrix;
            bool layoutAvailable = true;

            //			context.SelectFont ( font.nativeFont.PostScriptName,
            //			                    font.SizeInPoints,
            //			                    CGTextEncoding.MacRoman);
            //
            //			context.SetCharacterSpacing(1);
            //			context.SetTextDrawingMode(CGTextDrawingMode.Fill); // 5
            //
            //			// Setup both the stroke and the fill ?
            //			brush.Setup(this, true);
            //			brush.Setup(this, false);
            //
            //			var textMatrix = font.nativeFont.Matrix;
            //
            //			textMatrix.Scale(1,-1);
            //			context.TextMatrix = textMatrix;
            //
            //			context.ShowTextAtPoint(layoutRectangle.X,
            //			                        layoutRectangle.Y + font.nativeFont.CapHeightMetric, s);
            //
            //
            // First we call the brush with a fill of false so the brush can setup the stroke color
            // that the text will be using.
            // For LinearGradientBrush this will setup a TransparentLayer so the gradient can
            // be filled at the end.  See comments.
            brush.Setup(this, false);             // Stroke

            // I think we only Fill the text with no Stroke surrounding
            context.SetTextDrawingMode(CGTextDrawingMode.Fill);

            var attributedString = buildAttributedString(s, font, format, lastBrushColor);

            // Work out the geometry
            RectangleF insetBounds = layoutRectangle;

            if (insetBounds.Size == SizeF.Empty)
            {
                insetBounds.Width  = boundingBox.Width;
                insetBounds.Height = boundingBox.Height;
                layoutAvailable    = false;

                if (format.LineAlignment != StringAlignment.Near)
                {
                    insetBounds.Size = MeasureString(s, font);
                }
            }

            PointF textPosition = new PointF(insetBounds.X,
                                             insetBounds.Y);

            float boundsWidth = insetBounds.Width;

            // Calculate the lines
            int   start          = 0;
            int   length         = (int)attributedString.Length;
            float baselineOffset = 0;

            var typesetter = new CTTypesetter(attributedString);

            // First we need to calculate the offset for Vertical Alignment if we
            // are using anything but Top
            if (layoutAvailable && format.LineAlignment != StringAlignment.Near)
            {
                while (start < length)
                {
                    int count = (int)typesetter.SuggestLineBreak(start, boundsWidth);
                    var line  = typesetter.GetLine(new NSRange(start, count));

                    // Create and initialize some values from the bounds.
                    nfloat ascent;
                    nfloat descent;
                    nfloat leading;
                    line.GetTypographicBounds(out ascent, out descent, out leading);
                    baselineOffset += (float)Math.Ceiling(ascent + descent + leading + 1);                      // +1 matches best to CTFramesetter's behavior
                    line.Dispose();
                    start += count;
                }

                start = 0;
            }

            // If we are drawing vertial direction then we need to rotate our context transform by 90 degrees
            if ((format.FormatFlags & StringFormatFlags.DirectionVertical) == StringFormatFlags.DirectionVertical)
            {
                //textMatrix.Rotate (ConversionHelpers.DegreesToRadians (90));
                var verticalOffset = 0.0f;
                while (start < length)
                {
                    int count = (int)typesetter.SuggestLineBreak(start, boundsWidth);
                    var line  = typesetter.GetLine(new NSRange(start, count));

                    // Create and initialize some values from the bounds.
                    nfloat ascent;
                    nfloat descent;
                    nfloat leading;
                    line.GetTypographicBounds(out ascent, out descent, out leading);
                    verticalOffset += (float)Math.Ceiling(ascent + descent + leading + 1);                      // +1 matches best to CTFramesetter's behavior
                    line.Dispose();
                    start += count;
                }
                context.TranslateCTM(layoutRectangle.X, layoutRectangle.Y);
                context.RotateCTM(ConversionHelpers.DegreesToRadians(90));
                context.TranslateCTM(-layoutRectangle.X, -layoutRectangle.Y);
                context.TranslateCTM(0, -verticalOffset);
                start = 0;
            }

            start = 0;
            while (start < length && textPosition.Y < insetBounds.Bottom)
            {
                // Now we ask the typesetter to break off a line for us.
                // This also will take into account line feeds embedded in the text.
                //  Example: "This is text \n with a line feed embedded inside it"
                int count = (int)typesetter.SuggestLineBreak(start, boundsWidth);
                var line  = typesetter.GetLine(new NSRange(start, count));

                // Create and initialize some values from the bounds.
                nfloat ascent;
                nfloat descent;
                nfloat leading;
                double lineWidth = line.GetTypographicBounds(out ascent, out descent, out leading);

                // Calculate the string format if need be
                var penFlushness = 0.0f;
                if (format != null)
                {
                    if (layoutAvailable)
                    {
                        if (format.Alignment == StringAlignment.Far)
                        {
                            penFlushness = (float)line.GetPenOffsetForFlush(1.0f, boundsWidth);
                        }
                        else if (format.Alignment == StringAlignment.Center)
                        {
                            penFlushness = (float)line.GetPenOffsetForFlush(0.5f, boundsWidth);
                        }
                    }
                    else
                    {
                        // We were only passed in a point so we need to format based
                        // on the point.
                        if (format.Alignment == StringAlignment.Far)
                        {
                            penFlushness -= (float)lineWidth;
                        }
                        else if (format.Alignment == StringAlignment.Center)
                        {
                            penFlushness -= (float)lineWidth / 2.0f;
                        }
                    }
                }

                // initialize our Text Matrix or we could get trash in here
                var textMatrix = new CGAffineTransform(
                    1, 0, 0, -1, 0, ascent);

                if (format.LineAlignment == StringAlignment.Near)
                {
                    textMatrix.Translate(penFlushness + textPosition.X, textPosition.Y);
                }
                if (format.LineAlignment == StringAlignment.Center)
                {
                    if (layoutAvailable)
                    {
                        textMatrix.Translate(penFlushness + textPosition.X, textPosition.Y + ((insetBounds.Height / 2) - (baselineOffset / 2)));
                    }
                    else
                    {
                        textMatrix.Translate(penFlushness + textPosition.X, textPosition.Y - ((insetBounds.Height / 2) - (baselineOffset / 2)));
                    }
                }

                if (format.LineAlignment == StringAlignment.Far)
                {
                    if (layoutAvailable)
                    {
                        textMatrix.Translate(penFlushness + textPosition.X, textPosition.Y + ((insetBounds.Height) - (baselineOffset)));
                    }
                    else
                    {
                        textMatrix.Translate(penFlushness + textPosition.X, textPosition.Y - ((insetBounds.Height) - (baselineOffset)));
                    }
                }

                context.TextMatrix = textMatrix;

                // and draw the line
                line.Draw(context);

                // Move the index beyond the line break.
                start          += count;
                textPosition.Y += (float)Math.Ceiling(ascent + descent + leading + 1);                 // +1 matches best to CTFramesetter's behavior
                line.Dispose();
            }

            // Now we call the brush with a fill of true so the brush can do the fill if need be
            // For LinearGradientBrush this will draw the Gradient and end the TransparentLayer.
            // See comments.
            brush.Setup(this, true);             // Fill

            context.TextMatrix = saveMatrix;
            context.RestoreState();
        }
			public override void Draw (RectangleF rect)
			{
				// Initialize a graphics context and set the text matrix to a known value
				var context = UIGraphics.GetCurrentContext ();
				context.TextMatrix = CGAffineTransform.MakeScale (1f, -1f);

				var attrString = new NSAttributedString ("This is a long string.  You will only see half");
				var typesetter = new CTTypesetter (attrString);

				// Find a break for line from the beginning of the string to the given width
				int start = 0;
				var width = Frame.Width / 2;
				Console.WriteLine ("# ManualBreak: width={0}", width);
				width = 125;
				var count = typesetter.SuggestLineBreak (start, width);
				Console.WriteLine ("# ManualBreak: count={0}", count);

				// use the character count (to the break) to create the line:
				using (var line = typesetter.GetLine (new NSRange (start, count))) {
					// Get the offset needed to center the line:
					var flush = 0.5f;   // centered
					var penOffset = line.GetPenOffsetForFlush (flush, Frame.Width);
					Console.WriteLine ("# ManualBreak: pen offset={0}", penOffset);

					// Move the given text drawing position by the calculated offset and draw
					var curPosition = context.TextPosition;
					Console.WriteLine ("# ManualBreak: curPosition.X={0}", curPosition.X);
					context.TextPosition = new PointF ((float) penOffset, base.Center.Y);
					line.Draw (context);

					// move the index beyond the line break; why?
					start += count;
				}
			}
        public void DrawString(string s, Font font, Brush brush, RectangleF layoutRectangle, StringFormat format = null)
        {
            if (font == null)
                throw new ArgumentNullException ("font");
            if (brush == null)
                throw new ArgumentNullException ("brush");
            if (s == null || s.Length == 0)
                return;

            if (format == null)
            {
                format = StringFormat.GenericDefault;
            }

            // TODO: Take into consideration units

            // Not sure we need the Save and Restore around this yet.
            context.SaveState();

            // TextMatrix is not part of the Graphics State and Restore
            var saveMatrix = context.TextMatrix;
            bool layoutAvailable = true;

            //			context.SelectFont ( font.nativeFont.PostScriptName,
            //			                    font.SizeInPoints,
            //			                    CGTextEncoding.MacRoman);
            //
            //			context.SetCharacterSpacing(1);
            //			context.SetTextDrawingMode(CGTextDrawingMode.Fill); // 5
            //
            //			// Setup both the stroke and the fill ?
            //			brush.Setup(this, true);
            //			brush.Setup(this, false);
            //
            //			var textMatrix = font.nativeFont.Matrix;
            //
            //			textMatrix.Scale(1,-1);
            //			context.TextMatrix = textMatrix;
            //
            //			context.ShowTextAtPoint(layoutRectangle.X,
            //			                        layoutRectangle.Y + font.nativeFont.CapHeightMetric, s);
            //
            //
            // First we call the brush with a fill of false so the brush can setup the stroke color
            // that the text will be using.
            // For LinearGradientBrush this will setup a TransparentLayer so the gradient can
            // be filled at the end.  See comments.
            brush.Setup(this, false); // Stroke

            // I think we only Fill the text with no Stroke surrounding
            context.SetTextDrawingMode(CGTextDrawingMode.Fill);

            var attributedString = buildAttributedString(s, font, format, lastBrushColor);

            // Work out the geometry
            RectangleF insetBounds = layoutRectangle;
            if (insetBounds.Size == SizeF.Empty)
            {
                insetBounds.Width = boundingBox.Width;
                insetBounds.Height = boundingBox.Height;
                layoutAvailable = false;

                if (format.LineAlignment != StringAlignment.Near)
                {
                    insetBounds.Size = MeasureString (s, font);
                }

            }

            PointF textPosition = new PointF(insetBounds.X,
                                             insetBounds.Y);

            float boundsWidth = insetBounds.Width;

            // Calculate the lines
            int start = 0;
            int length = (int)attributedString.Length;
            float baselineOffset = 0;

            var typesetter = new CTTypesetter(attributedString);

            // First we need to calculate the offset for Vertical Alignment if we
            // are using anything but Top
            if (layoutAvailable && format.LineAlignment != StringAlignment.Near) {
                while (start < length) {
                    int count = (int)typesetter.SuggestLineBreak (start, boundsWidth);
                    var line = typesetter.GetLine (new NSRange(start, count));

                    // Create and initialize some values from the bounds.
                    nfloat ascent;
                    nfloat descent;
                    nfloat leading;
                    line.GetTypographicBounds (out ascent, out descent, out leading);
                    baselineOffset += (float)Math.Ceiling (ascent + descent + leading + 1); // +1 matches best to CTFramesetter's behavior
                    line.Dispose ();
                    start += count;
                }

                start = 0;
            }

            // If we are drawing vertial direction then we need to rotate our context transform by 90 degrees
            if ((format.FormatFlags & StringFormatFlags.DirectionVertical) == StringFormatFlags.DirectionVertical)
            {
                //textMatrix.Rotate (ConversionHelpers.DegreesToRadians (90));
                var verticalOffset = 0.0f;
                while (start < length) {
                    int count = (int)typesetter.SuggestLineBreak (start, boundsWidth);
                    var line = typesetter.GetLine (new NSRange(start, count));

                    // Create and initialize some values from the bounds.
                    nfloat ascent;
                    nfloat descent;
                    nfloat leading;
                    line.GetTypographicBounds (out ascent, out descent, out leading);
                    verticalOffset += (float)Math.Ceiling (ascent + descent + leading + 1); // +1 matches best to CTFramesetter's behavior
                    line.Dispose ();
                    start += count;
                }
                context.TranslateCTM (layoutRectangle.X, layoutRectangle.Y);
                context.RotateCTM (ConversionHelpers.DegreesToRadians (90));
                context.TranslateCTM (-layoutRectangle.X, -layoutRectangle.Y);
                context.TranslateCTM (0, -verticalOffset);
                start = 0;
            }

            start = 0;
            while (start < length && textPosition.Y < insetBounds.Bottom)
            {

                // Now we ask the typesetter to break off a line for us.
                // This also will take into account line feeds embedded in the text.
                //  Example: "This is text \n with a line feed embedded inside it"
                int count = (int)typesetter.SuggestLineBreak(start, boundsWidth);
                var line = typesetter.GetLine(new NSRange(start, count));

                // Create and initialize some values from the bounds.
                nfloat ascent;
                nfloat descent;
                nfloat leading;
                double lineWidth = line.GetTypographicBounds(out ascent, out descent, out leading);

                // Calculate the string format if need be
                var penFlushness = 0.0f;
                if (format != null)
                {
                    if (layoutAvailable)
                    {
                        if (format.Alignment == StringAlignment.Far)
                            penFlushness = (float)line.GetPenOffsetForFlush(1.0f, boundsWidth);
                        else if (format.Alignment == StringAlignment.Center)
                            penFlushness = (float)line.GetPenOffsetForFlush(0.5f, boundsWidth);
                    }
                    else
                    {
                        // We were only passed in a point so we need to format based
                        // on the point.
                        if (format.Alignment == StringAlignment.Far)
                            penFlushness -= (float)lineWidth;
                        else if (format.Alignment == StringAlignment.Center)
                            penFlushness -= (float)lineWidth / 2.0f;

                    }

                }

                // initialize our Text Matrix or we could get trash in here
                var textMatrix = new CGAffineTransform (
                    1, 0, 0, -1, 0, ascent);

                if (format.LineAlignment == StringAlignment.Near)
                    textMatrix.Translate (penFlushness + textPosition.X, textPosition.Y);
                if (format.LineAlignment == StringAlignment.Center)
                {
                    if (layoutAvailable)
                        textMatrix.Translate (penFlushness + textPosition.X, textPosition.Y + ((insetBounds.Height / 2) - (baselineOffset / 2)));
                    else
                        textMatrix.Translate (penFlushness + textPosition.X, textPosition.Y - ((insetBounds.Height / 2) - (baselineOffset / 2)));
                }

                if (format.LineAlignment == StringAlignment.Far)
                {
                    if (layoutAvailable)
                        textMatrix.Translate (penFlushness + textPosition.X, textPosition.Y + ((insetBounds.Height) - (baselineOffset)));
                    else
                        textMatrix.Translate (penFlushness + textPosition.X, textPosition.Y - ((insetBounds.Height) - (baselineOffset)));
                }

                context.TextMatrix = textMatrix;

                // and draw the line
                line.Draw(context);

                // Move the index beyond the line break.
                start += count;
                textPosition.Y += (float)Math.Ceiling(ascent + descent + leading + 1); // +1 matches best to CTFramesetter's behavior
                line.Dispose();

            }

            // Now we call the brush with a fill of true so the brush can do the fill if need be
            // For LinearGradientBrush this will draw the Gradient and end the TransparentLayer.
            // See comments.
            brush.Setup(this, true); // Fill

            context.TextMatrix = saveMatrix;
            context.RestoreState();
        }
        public SizeF MeasureString(string textg, Font font, RectangleF rect)
        {
            // As per documentation
            // https://developer.apple.com/library/mac/#documentation/GraphicsImaging/Conceptual/drawingwithquartz2d/dq_text/dq_text.html#//apple_ref/doc/uid/TP30001066-CH213-TPXREF101
            //
            // * Note * Not sure if we should save off the graphic state, set context transform to identity
            //  and restore state to do the measurement.  Something to be looked into.
            //			context.TextPosition = rect.Location;
            //			var startPos = context.TextPosition;
            //			context.SelectFont ( font.nativeFont.PostScriptName,
            //			                    font.SizeInPoints,
            //			                    CGTextEncoding.MacRoman);
            //			context.SetTextDrawingMode(CGTextDrawingMode.Invisible);
            //
            //			context.SetCharacterSpacing(1);
            //			var textMatrix = CGAffineTransform.MakeScale(1f,-1f);
            //			context.TextMatrix = textMatrix;
            //
            //			context.ShowTextAtPoint(rect.X, rect.Y, textg, textg.Length);
            //			var endPos = context.TextPosition;
            //
            //			var measure = new SizeF(endPos.X - startPos.X, font.nativeFont.CapHeightMetric);

            var atts = buildAttributedString(textg, font);

            var measure = SizeF.Empty;
            // Calculate the lines
            int start = 0;
            int length = (int)atts.Length;

            var typesetter = new CTTypesetter(atts);

            while (start < length) {
                int count = (int)typesetter.SuggestLineBreak (start, 8388608);
                var line = typesetter.GetLine (new NSRange(start, count));

                // Create and initialize some values from the bounds.
                nfloat ascent;
                nfloat descent;
                nfloat leading;
                var lineWidth = line.GetTypographicBounds (out ascent, out descent, out leading);

                measure.Height += (float)Math.Ceiling (ascent + descent + leading + 1); // +1 matches best to CTFramesetter's behavior
                if (lineWidth > measure.Width)
                    measure.Width = (float)lineWidth;

                line.Dispose ();
                start += count;
            }

            return measure;
        }
Beispiel #10
0
        internal static void NativeDrawString(CGBitmapContext bitmapContext, string s, CTFont font, CCColor4B brush, RectangleF layoutRectangle)
        {
            if (font == null)
            {
                throw new ArgumentNullException("font");
            }

            if (s == null || s.Length == 0)
            {
                return;
            }

            bitmapContext.ConcatCTM(bitmapContext.GetCTM().Invert());

            // This is not needed here since the color is set in the attributed string.
            //bitmapContext.SetFillColor(brush.R/255f, brush.G/255f, brush.B/255f, brush.A/255f);

            // I think we only Fill the text with no Stroke surrounding
            //bitmapContext.SetTextDrawingMode(CGTextDrawingMode.Fill);

            var attributedString = buildAttributedString(s, font, brush);

            // Work out the geometry
            RectangleF insetBounds = layoutRectangle;

            PointF textPosition = new PointF(insetBounds.X,
                                             insetBounds.Y);

            float boundsWidth = insetBounds.Width;

            // Calculate the lines
            int start  = 0;
            int length = attributedString.Length;

            var typesetter = new CTTypesetter(attributedString);

            float baselineOffset = 0;

            // First we need to calculate the offset for Vertical Alignment if we
            // are using anything but Top
            if (vertical != CCVerticalTextAlignment.Top)
            {
                while (start < length)
                {
                    int count = typesetter.SuggestLineBreak(start, boundsWidth);
                    var line  = typesetter.GetLine(new NSRange(start, count));

                    // Create and initialize some values from the bounds.
                    float ascent;
                    float descent;
                    float leading;
                    line.GetTypographicBounds(out ascent, out descent, out leading);
                    baselineOffset += (float)Math.Ceiling(ascent + descent + leading + 1);                      // +1 matches best to CTFramesetter's behavior
                    line.Dispose();
                    start += count;
                }
            }

            start = 0;

            while (start < length && textPosition.Y < insetBounds.Bottom)
            {
                // Now we ask the typesetter to break off a line for us.
                // This also will take into account line feeds embedded in the text.
                //  Example: "This is text \n with a line feed embedded inside it"
                int count = typesetter.SuggestLineBreak(start, boundsWidth);
                var line  = typesetter.GetLine(new NSRange(start, count));

                // Create and initialize some values from the bounds.
                float ascent;
                float descent;
                float leading;
                line.GetTypographicBounds(out ascent, out descent, out leading);

                // Calculate the string format if need be
                var penFlushness = 0.0f;

                if (horizontal == CCTextAlignment.Right)
                {
                    penFlushness = (float)line.GetPenOffsetForFlush(1.0f, boundsWidth);
                }
                else if (horizontal == CCTextAlignment.Center)
                {
                    penFlushness = (float)line.GetPenOffsetForFlush(0.5f, boundsWidth);
                }

                // initialize our Text Matrix or we could get trash in here
                var textMatrix = CGAffineTransform.MakeIdentity();

                if (vertical == CCVerticalTextAlignment.Top)
                {
                    textMatrix.Translate(penFlushness, insetBounds.Height - textPosition.Y - (float)Math.Floor(ascent - 1));
                }
                if (vertical == CCVerticalTextAlignment.Center)
                {
                    textMatrix.Translate(penFlushness, ((insetBounds.Height / 2) + (baselineOffset / 2)) - textPosition.Y - (float)Math.Floor(ascent - 1));
                }
                if (vertical == CCVerticalTextAlignment.Bottom)
                {
                    textMatrix.Translate(penFlushness, baselineOffset - textPosition.Y - (float)Math.Floor(ascent - 1));
                }

                // Set our matrix
                bitmapContext.TextMatrix = textMatrix;

                // and draw the line
                line.Draw(bitmapContext);

                // Move the index beyond the line break.
                start          += count;
                textPosition.Y += (float)Math.Ceiling(ascent + descent + leading + 1);                 // +1 matches best to CTFramesetter's behavior
                line.Dispose();
            }
        }
        private List <CTLine> CreateLines(Font font, NSAttributedString attributedString, SizeF layoutBox, StringFormat format, float lineHeight)
        {
            bool noWrap     = (format.FormatFlags & StringFormatFlags.NoWrap) != 0;
            bool wholeLines = (format.FormatFlags & StringFormatFlags.LineLimit) != 0;

            using (var typesetter = new CTTypesetter(attributedString))
            {
                var   lines  = new List <CTLine>();
                int   start  = 0;
                int   length = (int)attributedString.Length;
                float y      = 0;
                while (start < length && y < layoutBox.Height && (!wholeLines || y + lineHeight <= layoutBox.Height))
                {
                    if (format.Trimming != StringTrimming.None)
                    {
                        // Keep the last line in full when trimming is enabled
                        bool lastLine;
                        if (!wholeLines)
                        {
                            lastLine = y + lineHeight >= layoutBox.Height;
                        }
                        else
                        {
                            lastLine = y + lineHeight + lineHeight > layoutBox.Height;
                        }
                        if (lastLine)
                        {
                            noWrap = true;
                        }
                    }

                    // Now we ask the typesetter to break off a line for us.
                    // This also will take into account line feeds embedded in the text.
                    //  Example: "This is text \n with a line feed embedded inside it"
                    var count = (int)typesetter.SuggestLineBreak(start, noWrap ? double.MaxValue : layoutBox.Width);
                    var line  = typesetter.GetLine(new NSRange(start, count));

                    // Note: trimming may return a null line i.e. not enough space for any characters
                    var trim = line;
                    switch (format.Trimming)
                    {
                    case StringTrimming.Character:
                        trim = line.GetTruncatedLine(noWrap ? nfloat.MaxValue : layoutBox.Width, CTLineTruncation.End, null);
                        break;

                    case StringTrimming.EllipsisWord:                             // Fall thru for now
                    case StringTrimming.EllipsisCharacter:
                        using (CTLine ellipsisToken = EllipsisToken(font, format))
                        {
                            // Trimming when not necessary causes bad results
                            if (line.GetBounds(CTLineBoundsOptions.UseOpticalBounds).Width <= layoutBox.Width)
                            {
                                break;
                            }

                            trim = line.GetTruncatedLine(layoutBox.Width, CTLineTruncation.End, ellipsisToken);

                            //Put back the first letter if we got ellipsis only.
                            if (trim == null || trim.GlyphCount == 1 && trim.GetGlyphRuns()[0].GetGlyphs()[0] == ellipsisToken.GetGlyphRuns()[0].GetGlyphs()[0])
                            {
                                var plain      = attributedString.Value.Substring(0, 1) + "\u2026";
                                var attributed = buildAttributedString(plain, font, format, lastBrushColor);
                                trim = new CTLine(attributed);
                            }
                        }
                        break;

                    case StringTrimming.EllipsisPath:
                        using (CTLine ellipsisToken = EllipsisToken(font, format))
                            trim = line.GetTruncatedLine(layoutBox.Width, CTLineTruncation.Middle, ellipsisToken) ?? line;
                        break;
                    }

                    if (trim != null)
                    {
                        lines.Add(trim);
                    }

                    if (line != trim)
                    {
                        line.Dispose();
                    }

                    start += (int)count;
                    y     += (float)lineHeight;
                }
                return(lines);
            }
        }
        public void DrawString(string s, Font font, Brush brush, RectangleF layoutRectangle, StringFormat format = null)
        {
            if (font == null)
            {
                throw new ArgumentNullException("font");
            }
            if (brush == null)
            {
                throw new ArgumentNullException("brush");
            }
            if (s == null || s.Length == 0)
            {
                return;
            }

            // TODO: Take into consideration units

            // Not sure we need the Save and Restore around this yet.
            context.SaveState();

            // TextMatrix is not part of the Graphics State and Restore
            var  saveMatrix      = context.TextMatrix;
            bool layoutAvailable = true;

            //			context.SelectFont ( font.nativeFont.PostScriptName,
            //			                    font.SizeInPoints,
            //			                    CGTextEncoding.MacRoman);
            //
            //			context.SetCharacterSpacing(1);
            //			context.SetTextDrawingMode(CGTextDrawingMode.Fill); // 5
            //
            //			// Setup both the stroke and the fill ?
            //			brush.Setup(this, true);
            //			brush.Setup(this, false);
            //
            //			var textMatrix = font.nativeFont.Matrix;
            //
            //			textMatrix.Scale(1,-1);
            //			context.TextMatrix = textMatrix;
            //
            //			context.ShowTextAtPoint(layoutRectangle.X,
            //			                        layoutRectangle.Y + font.nativeFont.CapHeightMetric, s);
            //
            //
            // First we call the brush with a fill of false so the brush can setup the stroke color
            // that the text will be using.
            // For LinearGradientBrush this will setup a TransparentLayer so the gradient can
            // be filled at the end.  See comments.
            brush.Setup(this, false);             // Stroke

            // I think we only Fill the text with no Stroke surrounding
            context.SetTextDrawingMode(CGTextDrawingMode.Fill);

            var attributedString = buildAttributedString(s, font, lastBrushColor);

            // Work out the geometry
            RectangleF insetBounds = layoutRectangle;

            if (insetBounds.Size == SizeF.Empty)
            {
                insetBounds.Width  = boundingBox.Width;
                insetBounds.Height = boundingBox.Height;
                layoutAvailable    = false;
            }

            PointF textPosition = new PointF(insetBounds.X,
                                             insetBounds.Y);

            float boundsWidth = insetBounds.Width;

            // Calculate the lines
            int start  = 0;
            int length = attributedString.Length;

            var typesetter = new CTTypesetter(attributedString);

            while (start < length && textPosition.Y < insetBounds.Bottom)
            {
                // Now we ask the typesetter to break off a line for us.
                // This also will take into account line feeds embedded in the text.
                //  Example: "This is text \n with a line feed embedded inside it"
                int count = typesetter.SuggestLineBreak(start, boundsWidth);
                var line  = typesetter.GetLine(new NSRange(start, count));

                // Create and initialize some values from the bounds.
                float  ascent;
                float  descent;
                float  leading;
                double lineWidth = line.GetTypographicBounds(out ascent, out descent, out leading);

                // Calculate the string format if need be
                var penFlushness = 0.0f;
                if (format != null)
                {
                    if (layoutAvailable)
                    {
                        if (format.Alignment == StringAlignment.Far)
                        {
                            penFlushness = (float)line.GetPenOffsetForFlush(1.0f, boundsWidth);
                        }
                        else if (format.Alignment == StringAlignment.Center)
                        {
                            penFlushness = (float)line.GetPenOffsetForFlush(0.5f, boundsWidth);
                        }
                    }
                    else
                    {
                        // We were only passed in a point so we need to format based
                        // on the point.
                        if (format.Alignment == StringAlignment.Far)
                        {
                            penFlushness -= (float)lineWidth;
                        }
                        else if (format.Alignment == StringAlignment.Center)
                        {
                            penFlushness -= (float)lineWidth / 2.0f;
                        }
                    }
                }

                // initialize our Text Matrix or we could get trash in here
                var textMatrix = CGAffineTransform.MakeIdentity();
                // flip us over or things just do not look good
                textMatrix.Scale(1, -1);
                context.TextMatrix = textMatrix;

                // move us to our graphics baseline
                var textViewPos = textPosition;
                textViewPos.Y += (float)Math.Floor(ascent - 1);

                // take into account our justification
                textViewPos.X += penFlushness;

                // setup our text position
                context.TextPosition = textViewPos;
                // and draw the line
                line.Draw(context);

                // Move the index beyond the line break.
                start          += count;
                textPosition.Y += (float)Math.Ceiling(ascent + descent + leading + 1);                 // +1 matches best to CTFramesetter's behavior
                line.Dispose();
            }

            // Now we call the brush with a fill of true so the brush can do the fill if need be
            // For LinearGradientBrush this will draw the Gradient and end the TransparentLayer.
            // See comments.
            brush.Setup(this, true);             // Fill

            context.TextMatrix = saveMatrix;
            context.RestoreState();
        }
        internal void NativeDrawString(string s, Font font, Color brush, RectangleF layoutRectangle, StringFormat stringFormat)
        {
            if (font == null)
                throw new ArgumentNullException ("font");

            if (s == null || s.Length == 0)
                return;

            var attributedString = buildAttributedString(s, font, brush);

            // Work out the geometry
            RectangleF insetBounds = layoutRectangle;
            bool layoutAvailable = true;

            if (insetBounds.Size == SizeF.Empty)
            {
                insetBounds.Size = new SizeF (8388608, 8388608);
                layoutAvailable = false;
            }

            PointF textPosition = new PointF(insetBounds.X,
                                             insetBounds.Y);

            float boundsWidth = insetBounds.Width;

            // Calculate the lines
            int start = 0;
            int length = (int)attributedString.Length;

            var typesetter = new CTTypesetter(attributedString);

            float baselineOffset = 0;

            // First we need to calculate the offset for Vertical Alignment if we
            // are using anything but Top
            if (layoutAvailable && stringFormat.LineAlignment != StringAlignment.Near) {
                while (start < length) {
                    int count = (int)typesetter.SuggestLineBreak (start, boundsWidth);
                    var line = typesetter.GetLine (new NSRange(start, count));

                    // Create and initialize some values from the bounds.
                    nfloat ascent;
                    nfloat descent;
                    nfloat leading;
                    line.GetTypographicBounds (out ascent, out descent, out leading);
                    baselineOffset += (float)Math.Ceiling (ascent + descent + leading + 1); // +1 matches best to CTFramesetter's behavior
                    line.Dispose ();
                    start += count;
                }
            }

            start = 0;

            while (start < length && textPosition.Y < insetBounds.Bottom)
            {

                // Now we ask the typesetter to break off a line for us.
                // This also will take into account line feeds embedded in the text.
                //  Example: "This is text \n with a line feed embedded inside it"
                int count = (int)typesetter.SuggestLineBreak(start, boundsWidth);
                var line = typesetter.GetLine(new NSRange(start, count));

                // Create and initialize some values from the bounds.
                nfloat ascent;
                nfloat descent;
                nfloat leading;
                double lineWidth = line.GetTypographicBounds(out ascent, out descent, out leading);

                if (!layoutAvailable)
                {
                    insetBounds.Width = (float)lineWidth;
                    insetBounds.Height = (float)(ascent + descent + leading);
                }

                // Calculate the string format if need be
                var penFlushness = 0.0f;

                if (stringFormat.Alignment == StringAlignment.Far)
                    penFlushness = (float)line.GetPenOffsetForFlush(1.0f, insetBounds.Width);
                else if (stringFormat.Alignment == StringAlignment.Center)
                    penFlushness = (float)line.GetPenOffsetForFlush(0.5f, insetBounds.Width);

                // initialize our Text Matrix or we could get trash in here
                var textMatrix = new CGAffineTransform (
                                     1, 0, 0, -1, 0, ascent);

                if (stringFormat.LineAlignment == StringAlignment.Near)
                    textMatrix.Translate (penFlushness + textPosition.X, textPosition.Y); //insetBounds.Height - textPosition.Y -(float)Math.Floor(ascent - 1));
                if (stringFormat.LineAlignment == StringAlignment.Center)
                    textMatrix.Translate (penFlushness + textPosition.X, textPosition.Y + ((insetBounds.Height / 2) - (baselineOffset / 2)) );  // -(float)Math.Floor(ascent)
                if (stringFormat.LineAlignment == StringAlignment.Far)
                    textMatrix.Translate(penFlushness + textPosition.X,  textPosition.Y + ((insetBounds.Height) - (baselineOffset)));

                var glyphRuns = line.GetGlyphRuns ();

                for (int glyphRunIndex = 0; glyphRunIndex < glyphRuns.Length; glyphRunIndex++)
                {

                    var glyphRun = glyphRuns [glyphRunIndex];
                    var glyphs = glyphRun.GetGlyphs ();
                    var glyphPositions = glyphRun.GetPositions ();
                    //var textMatrix = glyphRun.TextMatrix;

                    // Create and initialize some values from the bounds.
                    float glyphAscent;
                    float glyphDescent;
                    float glyphLeading;

                    var elementPoints = new PointF [3];

                    for (int glyphIndex = 0; glyphIndex < glyphs.Length; glyphIndex++)
                    {
                        if (glyphIndex > 0)
                        {
                            textMatrix.x0 += glyphPositions [glyphIndex].X - glyphPositions[glyphIndex - 1].X;
                            textMatrix.y0 += glyphPositions [glyphIndex].Y - glyphPositions[glyphIndex - 1].Y;
                        }

                        var glyphPath = font.nativeFont.GetPathForGlyph (glyphs [glyphIndex]);

                        // glyphPath = null if it is a white space character
                        if (glyphPath != null) {

                            glyphPath.Apply (
                                delegate (CGPathElement pathElement) {

                                    elementPoints[0] = textMatrix.TransformPoint(pathElement.Point1).ToPointF ();
                                    elementPoints[1] = textMatrix.TransformPoint(pathElement.Point2).ToPointF ();
                                        elementPoints[2] = textMatrix.TransformPoint(pathElement.Point3).ToPointF ();
                                //Console.WriteLine ("Applying {0} - {1}, {2}, {3}", pathElement.Type, elementPoints[0], elementPoints[1], elementPoints[2]);

                                        // now add position offsets
                                        switch(pathElement.Type)
                                        {
                                        case CGPathElementType.MoveToPoint:
                                            start_new_fig = true;
                                            Append(elementPoints[0].X, elementPoints[0].Y,PathPointType.Line,true);
                                            break;
                                        case CGPathElementType.AddLineToPoint:
                                            var lastPoint = points[points.Count - 1];
                                            AppendPoint(lastPoint, PathPointType.Line, false);
                                            AppendPoint(elementPoints[0], PathPointType.Line, false);
                                            break;
                                        case CGPathElementType.AddCurveToPoint:
                                        case CGPathElementType.AddQuadCurveToPoint:
                                            //  This is the only thing I can think of right now for the fonts that
                                            //  I have tested.  See the description of the quadraticToCubic method for
                                            //  more information

                                            // Get the last point
                                            var pt1 = points[points.Count - 1];
                                            var pt2 = PointF.Empty;
                                            var pt3 = PointF.Empty;
                                            var pt4 = elementPoints[1];
                                            GeomUtilities.QuadraticToCubic(pt1, elementPoints[0], elementPoints[1], out pt2, out pt3);
                                            Append (pt1.X, pt1.Y, PathPointType.Line, true);
                                            AppendBezier (pt2.X, pt2.Y, pt3.X, pt3.Y, pt4.X, pt4.Y);
                                            break;
                                        case CGPathElementType.CloseSubpath:
                                            CloseFigure();
                                            break;
                                        }

                                }

                            );
                        }

                    }
                }

                // Move the index beyond the line break.
                start += count;
                textPosition.Y += (float)Math.Ceiling(ascent + descent + leading + 1); // +1 matches best to CTFramesetter's behavior
                line.Dispose();

            }
        }