Plotter.cs

namespace ForestPlot
{
    using System;
    using System.Collections.Generic;
    using System.Drawing;
    using System.Drawing.Drawing2D;
    using System.Drawing.Imaging;
    using System.Globalization;
    using DashStyle = System.Drawing.Drawing2D.DashStyle;
    using StringBuilder = System.Text.StringBuilder;
    using TextRenderingHint = System.Drawing.Text.TextRenderingHint;

    public enum PlotTarget
    {
        None,
        Screen,
        Printer
    }

    public enum RangeScale
    {
        None,
        Linear,
        Log
    }

    public enum EndLabel
    {
        Auto,
        End,
        Interval,
        Both
    }

    public class Plotter
    {
        private const PixelFormat RenderPixelFormat = PixelFormat.Format32bppRgb;
        private const int Opaque = unchecked((int)0xff000000);

        private static readonly char[] lineBreakChars = { '\r', '\n' };
        private static readonly char[] optionsSplitChars = { ' ', ';', ',', '+', '/', '-', ':' };
        private static readonly char[] optionPartSplitChars = { '=' };

        private readonly List<string> headers = new List<string>();
        private readonly List<Row> rows = new List<Row>();
        private readonly List<VerticalLine> verticalLines = new List<VerticalLine>();
        private readonly List<float> columnInches = new List<float>();

        private RangeScale rangeScale;

        private int averageColumn;
        private int lowerColumn;
        private int upperColumn;
        private int groupColumn;
        private int optionsColumn;

        private int screenDpi;
        private bool screenAntialias;
        private bool screenColor;
        private int printerDpi;
        private bool printerAntialias;
        private bool printerColor;
        private float rangeMinX;
        private float rangeMaxX;
        private EndLabel labelMin;
        private EndLabel labelMax;
        private string labelFormat;
        private float averageAlignX;
        private float lowerAlignX;
        private float upperAlignX;
        private float tickIntervalX;
        private float labelIntervalX;
        private float penPoints;
        private float barPenPoints;
        private float arrowPoints;
        private int backColor;
        private int foreColor;
        private int headerColor;
        private int labelColor;
        private string label;
        private string fontName;
        private float fontPoints;
        private float rowLines;
        private float headerRowLines;
        private float leftMarginInches;
        private float rightMarginInches;
        private float topMarginInches;
        private float bottomMarginInches;
        private float backgroundLeftMarginInches;
        private float backgroundRightMarginInches;
        private float backgroundTopMarginLines;

        private string dataText;
        private string errorMessage;

        public event EventHandler DataChanged;

        public Plotter()
        {
            this.InitData("");
        }

        public string DataText
        {
            get
            {
                return this.dataText;
            }

            set
            {
                string dataOrBlank = value ?? "";
                if (dataOrBlank != this.dataText)
                {
                    this.InitData(dataOrBlank);
                    var handler = this.DataChanged;
                    if (handler != null)
                    {
                        handler(this, EventArgs.Empty);
                    }
                }
            }
        }

        public Bitmap Render(PlotTarget target, string emfPath = null)
        {
            if (!string.IsNullOrEmpty(this.errorMessage))
            {
                throw new InvalidOperationException(this.errorMessage);
            }

            Bitmap result;

            float dotsPerInch;
            TextRenderingHint textRenderingHint;
            bool color;

            switch (target)
            {
                default:
                    throw new InvalidOperationException("Bad target parameter");

                case PlotTarget.Screen:
                    dotsPerInch = this.screenDpi;
                    textRenderingHint =  this.screenAntialias
                        ? TextRenderingHint.AntiAliasGridFit
                        : TextRenderingHint.SingleBitPerPixelGridFit;
                    color = this.screenColor;
                    break;

                case PlotTarget.Printer:
                    dotsPerInch = this.printerDpi;
                    textRenderingHint = this.printerAntialias
                        ? TextRenderingHint.AntiAliasGridFit
                        : TextRenderingHint.SingleBitPerPixelGridFit;
                    color = this.printerColor;
                    break;
            }

            bool targetEmf = emfPath != null;
            if (targetEmf)
            {
                dotsPerInch = 96.0f;
            }

            var dotsPerPoint = dotsPerInch / 72.0f;
            var dotsPerLine = this.fontPoints * dotsPerPoint; // Should have been regFont.GetHeight(dotsPerInch). Too late now.
            var dotsPerRow = this.rowLines * dotsPerLine;
            var dotsPerArrow = this.arrowPoints * dotsPerPoint;
            var dotsPerGrouping = 0.75f * dotsPerLine;
            var dotsPerColumnMargin = dotsPerLine;
            float dotsPerTopMargin = this.topMarginInches * dotsPerInch;
            float dotsPerBottomMargin = this.bottomMarginInches * dotsPerInch;
            float dotsPerLeftMargin = this.leftMarginInches * dotsPerInch;
            float dotsPerRightMargin = this.rightMarginInches * dotsPerInch;

            var dashes = new List<float>();
            var diamonds = new List<Diamond>();

            Font regFont = null;
            Font boldFont = null;
            Brush brush = null;
            Pen pen = null;
            Pen barPen = null;
            Bitmap bmp = null;

            Graphics emfGraphics = null;
            IntPtr emfHdc = IntPtr.Zero;
            Metafile emf = null;
            Graphics g = null;

            try
            {
                regFont = new Font(this.fontName, this.fontPoints, FontStyle.Regular);
                boldFont = new Font(regFont, FontStyle.Bold);

                brush = new SolidBrush(PickColor(this.foreColor, color));
                pen = new Pen(PickColor(this.foreColor, color), this.penPoints * dotsPerPoint);
                barPen = this.penPoints == this.barPenPoints
                    ? pen
                    : new Pen(PickColor(this.foreColor, color), this.barPenPoints * dotsPerPoint);

                bmp = new Bitmap(1, 1, RenderPixelFormat);
                bmp.SetResolution(dotsPerInch, dotsPerInch);
                g = Graphics.FromImage(bmp);

                float[] columnWidths = this.columnInches.ToArray();
                int lastColumnMargin = -1;
                for (int i = 0; i < columnWidths.Length; i++)
                {
                    if (columnWidths[i] != 0)
                    {
                        lastColumnMargin = -1;
                        columnWidths[i] *= dotsPerInch;
                    }
                    else if (
                        i == this.lowerColumn ||
                        i == this.upperColumn)
                    {
                        lastColumnMargin = -1;
                        columnWidths[i] = 0.1f * dotsPerInch;
                    }
                    else if (i == this.averageColumn)
                    {
                        lastColumnMargin = -1;
                        columnWidths[i] = 4f * dotsPerInch;
                    }
                    else if (i != this.optionsColumn)
                    {
                        var size = g.MeasureString(this.headers[i], boldFont);
                        float width = size.Width;

                        foreach (var r in this.rows)
                        {
                            size = g.MeasureString(r.Cells[i], r.Bold ? boldFont : regFont);
                            if (width < size.Width)
                            {
                                width = size.Width;
                            }
                        }

                        if (i == this.groupColumn)
                        {
                            width += dotsPerGrouping;
                        }

                        width += dotsPerColumnMargin;

                        lastColumnMargin = i;
                        columnWidths[i] = width;
                    }
                }

                // Don't count automatically-added intracolumn spacing in overall bitmap width.
                if (lastColumnMargin >= 0)
                {
                    columnWidths[lastColumnMargin] -= dotsPerColumnMargin;
                }

                float bmpWidth = dotsPerLeftMargin + dotsPerRightMargin;
                foreach (var col in columnWidths)
                {
                    bmpWidth += col;
                }

                float bmpHeight =
                    dotsPerTopMargin +
                    this.headerRowLines * dotsPerLine +
                    this.rowLines * (this.rows.Count + 2) * dotsPerLine +
                    dotsPerBottomMargin;

                g.Dispose();
                bmp.Dispose();

                bmp = new Bitmap((int)bmpWidth, (int)bmpHeight, RenderPixelFormat);
                bmp.SetResolution(dotsPerInch, dotsPerInch);

                if (!targetEmf)
                {
                    g = Graphics.FromImage(bmp);
                }
                else
                {
                    emfGraphics = Graphics.FromImage(bmp);
                    emfGraphics.SetClip(new RectangleF(0, 0, bmpWidth, bmpHeight));
                    emfHdc = emfGraphics.GetHdc();
                    emf = new Metafile(
                        emfPath,
                        emfHdc,
                        new RectangleF(0, 0, bmpWidth, bmpHeight),
                        MetafileFrameUnit.Pixel,
                        EmfType.EmfOnly);
                    var mfh = emf.GetMetafileHeader();
                    g = Graphics.FromImage(emf);

                    g.SmoothingMode = SmoothingMode.HighQuality;
                    g.InterpolationMode = InterpolationMode.HighQualityBicubic;
                    g.PixelOffsetMode = PixelOffsetMode.HighQuality;
                    g.CompositingQuality = CompositingQuality.HighQuality;

                    g.ScaleTransform(dotsPerInch / g.DpiX, dotsPerInch / g.DpiY);
                    g.PageUnit = GraphicsUnit.Pixel;
                    g.SetClip(new RectangleF(0, 0, bmpWidth, bmpHeight));
                }

                g.TextRenderingHint = textRenderingHint;
                g.Clear(PickColor(this.backColor, color));

                // Row background colors
                for (int r = 0; r < this.rows.Count; r++)
                {
                    if (this.rows[r].BackColor != this.backColor)
                    {
                        using (var b = new SolidBrush(PickColor(this.rows[r].BackColor, color)))
                        {
                            float x2 =
                                (this.leftMarginInches + this.backgroundLeftMarginInches) * dotsPerInch;
                            float w2 =
                                bmp.Width -
                                x2 -
                                (this.rightMarginInches + this.backgroundRightMarginInches) * dotsPerInch;
                            float y2 =
                                dotsPerTopMargin +
                                this.headerRowLines * dotsPerLine +
                                r * dotsPerRow - ((dotsPerRow - dotsPerLine) / 4) +
                                this.backgroundTopMarginLines * dotsPerLine;

                            g.FillRectangle(b, x2, y2, w2, dotsPerRow);
                        }
                    }
                }

                float x = dotsPerLeftMargin;
                float y = dotsPerTopMargin;
                float averageColumnWidth = columnWidths[this.averageColumn];
                float plotColumnWidth =
                    columnWidths[this.lowerColumn] +
                    columnWidths[this.averageColumn] +
                    columnWidths[this.upperColumn];

                using (var headerBrush = new SolidBrush(PickColor(this.headerColor, color)))
                {
                    for (int i = 0; i < this.headers.Count; i++)
                    {
                        if (i == this.averageColumn)
                        {
                            float plotLeft = x;
                            float plotRight = plotLeft + plotColumnWidth;
                            x += columnWidths[this.lowerColumn];

                            var fmt = new StringFormat();
                            fmt.FormatFlags = StringFormatFlags.NoClip | StringFormatFlags.NoWrap;

                            RectangleF box;
                            string s;
                            float textX;

                            s = this.headers[this.averageColumn];
                            if (!string.IsNullOrEmpty(s))
                            {
                                fmt.Alignment = StringAlignment.Center;
                                textX = PlotX(x, averageColumnWidth, this.averageAlignX);
                                box = new RectangleF(textX - plotColumnWidth / 2, y, plotColumnWidth, this.headerRowLines * dotsPerLine);
                                g.DrawString(s, boldFont, headerBrush, box, fmt);
                            }

                            s = this.headers[this.lowerColumn];
                            if (!string.IsNullOrEmpty(s))
                            {
                                fmt.Alignment = StringAlignment.Far;
                                textX = PlotX(x, averageColumnWidth, this.lowerAlignX);
                                box = new RectangleF(plotLeft, y, textX - plotLeft, this.headerRowLines * dotsPerLine);
                                g.DrawString(s, boldFont, headerBrush, box, fmt);
                            }

                            s = this.headers[this.upperColumn];
                            if (!string.IsNullOrEmpty(s))
                            {
                                fmt.Alignment = StringAlignment.Near;
                                textX = PlotX(x, averageColumnWidth, this.upperAlignX);
                                box = new RectangleF(textX, y, plotRight - textX, this.headerRowLines * dotsPerLine);
                                g.DrawString(s, boldFont, headerBrush, box, fmt);
                            }

                            x += averageColumnWidth + columnWidths[this.upperColumn];
                        }
                        else if (i == this.lowerColumn || i == this.upperColumn || i == this.optionsColumn)
                        {
                        }
                        else
                        {
                            var box = new RectangleF(x, y, columnWidths[i], this.headerRowLines * dotsPerLine);
                            var fmt = new StringFormat();
                            fmt.FormatFlags = StringFormatFlags.NoClip | StringFormatFlags.NoWrap;
                            g.DrawString(this.headers[i], boldFont, headerBrush, box, fmt);
                            x += columnWidths[i];
                        }
                    }
                }

                x = dotsPerLeftMargin;
                y += this.headerRowLines * dotsPerLine;

                float dataTop = y;
                string groupText = null;
                float groupTop = 0;
                bool groupBold = false;

                for (int r = 0; r < this.rows.Count; r++)
                {
                    var row = this.rows[r];
                    var rowBrush = brush;
                    var rowBarPen = barPen;

                    try
                    {
                        if (row.ForeColor != this.foreColor)
                        {
                            rowBrush = new SolidBrush(PickColor(row.ForeColor, color));
                            rowBarPen = new Pen(PickColor(row.ForeColor, color), this.barPenPoints * dotsPerPoint);
                        }

                        for (int i = 0; i < this.headers.Count; i++)
                        {
                            if (i == this.averageColumn && this.rows[r].Skip)
                            {
                                if (this.rows[r].Cells[this.lowerColumn] == "--")
                                {
                                    g.DrawLine(rowBarPen, x, y + dotsPerLine / 2, x + columnWidths[this.lowerColumn], y + dotsPerLine / 2);
                                }
                                x += columnWidths[this.lowerColumn];

                                if (this.rows[r].Cells[this.averageColumn] == "--")
                                {
                                    g.DrawLine(rowBarPen, x, y + dotsPerLine / 2, x + columnWidths[this.averageColumn], y + dotsPerLine / 2);
                                }
                                x += columnWidths[this.averageColumn];

                                if (this.rows[r].Cells[this.upperColumn] == "--")
                                {
                                    g.DrawLine(rowBarPen, x, y + dotsPerLine / 2, x + columnWidths[this.upperColumn], y + dotsPerLine / 2);
                                }
                                x += columnWidths[this.upperColumn];
                            }
                            else if (i == this.averageColumn && !this.rows[r].Skip)
                            {
                                x += columnWidths[this.lowerColumn];

                                float x1;
                                bool x1Arrow;
                                if (this.rows[r].Lower >= this.rangeMinX)
                                {
                                    x1 = this.PlotX(x, averageColumnWidth, this.rows[r].Lower);
                                    x1Arrow = false;
                                }
                                else
                                {
                                    x1 = x;
                                    x1Arrow = true;
                                }

                                float x2 = this.PlotX(x, averageColumnWidth, this.rows[r].Average);

                                float x3;
                                bool x3Arrow;
                                if (this.rows[r].Upper <= this.rangeMaxX)
                                {
                                    x3 = this.PlotX(x, averageColumnWidth, this.rows[r].Upper);
                                    x3Arrow = false;
                                }
                                else
                                {
                                    x3 = x + averageColumnWidth;
                                    x3Arrow = true;
                                }

                                g.DrawLine(rowBarPen, x2, y + dotsPerLine / 2, x1, y + dotsPerLine / 2);
                                if (x1Arrow)
                                {
                                    g.DrawLines(rowBarPen, new PointF[] {
                                    new PointF(x1 + dotsPerArrow, y + dotsPerLine / 2 - dotsPerArrow),
                                    new PointF(x1, y + dotsPerLine / 2),
                                    new PointF(x1 + dotsPerArrow, y + dotsPerLine / 2 + dotsPerArrow)
                                });
                                }

                                g.DrawLine(rowBarPen, x2, y + dotsPerLine / 2, x3, y + dotsPerLine / 2);
                                if (x3Arrow)
                                {
                                    g.DrawLines(rowBarPen, new PointF[] {
                                    new PointF(x3 - dotsPerArrow, y + dotsPerLine / 2 - dotsPerArrow),
                                    new PointF(x3, y + dotsPerLine / 2),
                                    new PointF(x3 - dotsPerArrow, y + dotsPerLine / 2 + dotsPerArrow)
                                });
                                }

                                if (this.rows[r].Dash)
                                {
                                    dashes.Add(x2);
                                }

                                if (this.rows[r].Diamond)
                                {
                                    diamonds.Add(new Diamond(this.rows[r], x2, y, dotsPerLine / 2));
                                }
                                else
                                {
                                    g.FillRectangle(rowBrush, x2 - dotsPerLine / 4, y + dotsPerLine / 4, dotsPerLine / 2, dotsPerLine / 2);
                                }

                                x += averageColumnWidth + columnWidths[this.upperColumn];
                            }
                            else if (i == this.groupColumn)
                            {
                                if (this.rows[r].GroupEnd ||
                                    this.rows[r].Cells[i].StartsWith("!", StringComparison.Ordinal))
                                {
                                    if (this.rows[r].Cells[i].Length > 1)
                                    {
                                        groupText = this.rows[r].GroupEnd
                                            ? this.rows[r].Cells[i]
                                            : this.rows[r].Cells[i].Substring(1);
                                        groupTop = y;
                                        groupBold = this.rows[r].Bold;
                                    }

                                    if (groupText != null)
                                    {
                                        float dotsPerGroupSection = dotsPerGrouping * (2f / 3f);
                                        g.DrawLines(pen, new PointF[] {
                                            new PointF(x, groupTop + dotsPerGroupSection),
                                            new PointF(x + dotsPerGroupSection, groupTop + dotsPerGroupSection),
                                            new PointF(x + dotsPerGroupSection, y + dotsPerGroupSection),
                                            new PointF(x, y + dotsPerGroupSection)
                                        });

                                        g.DrawString(
                                            groupText,
                                            groupBold ? boldFont : regFont,
                                            brush,
                                            x + dotsPerGrouping,
                                            (y + groupTop) / 2);
                                    }

                                    groupText = null;
                                    groupTop = 0;
                                    groupBold = false;
                                }
                                else if (this.rows[r].GroupStart || this.rows[r].Cells[i].Length != 0)
                                {
                                    groupText = this.rows[r].Cells[i];
                                    groupTop = y;
                                    groupBold = this.rows[r].Bold;
                                }

                                x += columnWidths[i];
                            }
                            else if (i == this.lowerColumn || i == this.upperColumn || i == this.optionsColumn)
                            {
                            }
                            else if (this.rows[r].Cells[i] == "--")
                            {
                                g.DrawLine(rowBarPen, x, y + dotsPerLine / 2, x + columnWidths[i], y + dotsPerLine / 2);
                                x += columnWidths[i];
                            }
                            else
                            {
                                g.DrawString(
                                    this.rows[r].Cells[i],
                                    this.rows[r].Bold ? boldFont : regFont,
                                    rowBrush,
                                    x,
                                    y);
                                x += columnWidths[i];
                            }
                        }

                        x = dotsPerLeftMargin;
                        y += dotsPerRow;
                    }
                    finally
                    {
                        if (rowBrush != brush)
                        {
                            rowBrush.Dispose();
                        }

                        if (rowBarPen != barPen)
                        {
                            rowBarPen.Dispose();
                        }
                    }
                }

                for (int i = 0; i < this.headers.Count; i++)
                {
                    if (i == this.averageColumn)
                    {
                        x += columnWidths[this.lowerColumn];

                        g.DrawLine(pen, x, y, x + averageColumnWidth, y);

                        foreach (var verticalLine in this.verticalLines)
                        {
                            if (this.rangeMinX <= verticalLine.X && verticalLine.X <= this.rangeMaxX)
                            {
                                var xPos = this.PlotX(x, averageColumnWidth, verticalLine.X);
                                pen.DashStyle = verticalLine.DashStyle;
                                g.DrawLine(pen, xPos, verticalLine.Extend ? dotsPerTopMargin : dataTop, xPos, y);
                            }
                        }

                        pen.DashStyle = DashStyle.Dash;
                        foreach (var lineX in dashes)
                        {
                            g.DrawLine(pen, lineX, y, lineX, dataTop);
                        }
                        pen.DashStyle = DashStyle.Solid;

                        foreach (var diamond in diamonds)
                        {
                            using (var b = new SolidBrush(PickColor(diamond.Row.BackColor, color)))
                            {
                                g.FillPolygon(b, diamond.Points);
                            }

                            using (var p = new Pen(PickColor(diamond.Row.ForeColor, color), this.barPenPoints * dotsPerPoint))
                            {
                                g.DrawPolygon(p, diamond.Points);
                            }
                        }

                        float labelMinWidth = this.labelMin != EndLabel.Interval
                            ? this.MajorTick(g, pen, regFont, brush, x, y, averageColumnWidth, dotsPerLine, this.rangeMinX, float.NegativeInfinity, float.PositiveInfinity, false)
                            : 0;
                        float labelMaxWidth = this.labelMax != EndLabel.Interval
                            ? this.MajorTick(g, pen, regFont, brush, x, y, averageColumnWidth, dotsPerLine, this.rangeMaxX, float.NegativeInfinity, float.PositiveInfinity, false)
                            : 0;
                        float labelMinCutoff = this.labelMin == EndLabel.Auto
                            ? this.PlotX(x, averageColumnWidth, this.rangeMinX) + labelMinWidth / 2
                            : float.NegativeInfinity;
                        float labelMaxCutoff = this.labelMax == EndLabel.Auto
                            ? this.PlotX(x, averageColumnWidth, this.rangeMaxX) - labelMaxWidth / 2
                            : float.PositiveInfinity;

                        if (this.rangeScale == RangeScale.Log)
                        {
                            if (this.labelIntervalX > 1.0)
                            {
                                for (double tick = 1.0; tick > this.rangeMinX / this.labelIntervalX; tick /= this.labelIntervalX)
                                {
                                    this.MajorTick(g, pen, regFont, brush, x, y, averageColumnWidth, dotsPerLine, (float)tick, labelMinCutoff, labelMaxCutoff,
                                        this.labelMin == EndLabel.End && tick < this.rangeMinX * this.labelIntervalX);
                                    if (this.tickIntervalX >= 2)
                                    {
                                        int minorTicks = (int)this.tickIntervalX;
                                        double tickSize = (tick * this.labelIntervalX - tick) / minorTicks;
                                        double minorTick = tick;
                                        for (var minor = 0; minor != minorTicks; minor++, minorTick += tickSize)
                                        {
                                            this.MinorTick(g, pen, x, y, averageColumnWidth, dotsPerLine, (float)minorTick);
                                        }
                                    }
                                }
                                for (double tick = this.labelIntervalX; tick <= this.rangeMaxX + 1.0; tick *= this.labelIntervalX)
                                {
                                    this.MajorTick(g, pen, regFont, brush, x, y, averageColumnWidth, dotsPerLine, (float)tick, labelMinCutoff, labelMaxCutoff,
                                        this.labelMax == EndLabel.End && tick > this.rangeMaxX / this.labelIntervalX);
                                    if (this.tickIntervalX >= 2)
                                    {
                                        int minorTicks = (int)this.tickIntervalX;
                                        double tickSize = (tick * this.labelIntervalX - tick) / minorTicks;
                                        double minorTick = tick;
                                        for (var minor = 0; minor != minorTicks; minor++, minorTick += tickSize)
                                        {
                                            this.MinorTick(g, pen, x, y, averageColumnWidth, dotsPerLine, (float)minorTick);
                                        }
                                    }
                                }
                            }
                        }
                        else
                        {
                            if (this.tickIntervalX > 0)
                            {
                                for (
                                    float tick = this.tickIntervalX * (float)Math.Floor(this.rangeMinX / this.tickIntervalX);
                                    tick <= (this.rangeMaxX + (this.rangeMaxX - this.rangeMinX) / 1000f);
                                    tick += this.tickIntervalX)
                                {
                                    this.MinorTick(g, pen, x, y, averageColumnWidth, dotsPerLine, tick);
                                }
                            }

                            if (this.labelIntervalX > 0)
                            {
                                var start = this.labelIntervalX * (float)Math.Floor(this.rangeMinX / this.labelIntervalX);
                                var end = (this.rangeMaxX + (this.rangeMaxX - this.rangeMinX) / 1000f);
                                for (float tick = start; tick <= end; tick += this.labelIntervalX)
                                {
                                    this.MajorTick(g, pen, regFont, brush, x, y, averageColumnWidth, dotsPerLine, tick, labelMinCutoff, labelMaxCutoff,
                                        this.labelMin == EndLabel.End && tick < this.rangeMinX + this.labelIntervalX ||
                                        this.labelMax == EndLabel.End && tick > this.rangeMaxX - this.labelIntervalX);
                                }
                            }
                        }

                        y += 0.6f * dotsPerLine + dotsPerRow;
                        if (!string.IsNullOrEmpty(this.label))
                        {
                            using (var labelBrush = new SolidBrush(PickColor(this.labelColor, color)))
                            {
                                g.DrawString(
                                this.label,
                                boldFont,
                                labelBrush,
                                x + (averageColumnWidth - g.MeasureString(this.label, boldFont).Width) / 2,
                                y);
                            }
                        }

                        break;
                    }
                    else if (i == this.lowerColumn || i == this.upperColumn || i == this.optionsColumn)
                    {
                    }
                    else
                    {
                        x += columnWidths[i];
                    }
                }

                result = bmp;
                bmp = null;
            }
            finally
            {
                if (pen != null)
                {
                    pen.Dispose();
                }

                if (barPen != null)
                {
                    barPen.Dispose();
                }

                if (brush != null)
                {
                    brush.Dispose();
                }

                if (regFont != null)
                {
                    regFont.Dispose();
                }

                if (boldFont != null)
                {
                    boldFont.Dispose();
                }

                if (g != null)
                {
                    g.Dispose();
                }

                if (emf != null)
                {
                    emf.Dispose();
                }

                if (emfHdc != IntPtr.Zero)
                {
                    emfGraphics.ReleaseHdc();
                }

                if (emfGraphics != null)
                {
                    emfGraphics.Dispose();
                }

                if (bmp != null)
                {
                    bmp.Dispose();
                }
            }

            return result;
        }

        public Bitmap RenderText(string message)
        {
            Bitmap result;

            const float Dpi = 96;
            Bitmap bmp = null;
            Graphics g = null;
            try
            {
                message = message ?? "Error";
                bmp = new Bitmap(1, 1, RenderPixelFormat);
                bmp.SetResolution(Dpi, Dpi);
                g = Graphics.FromImage(bmp);
                var size = g.MeasureString(message, SystemFonts.DefaultFont);
                g.Dispose();
                bmp.Dispose();
                bmp = new Bitmap((int)size.Width, (int)size.Height, RenderPixelFormat);
                bmp.SetResolution(Dpi, Dpi);
                g = Graphics.FromImage(bmp);
                g.Clear(SystemColors.Window);
                g.DrawString(message, SystemFonts.DefaultFont, SystemBrushes.WindowText, new PointF(0, 0));
                result = bmp;
                bmp = null;
            }
            finally
            {
                if (g != null)
                {
                    g.Dispose();
                }

                if (bmp != null)
                {
                    bmp.Dispose();
                }
            }

            return result;
        }

        private void MinorTick(
            Graphics g,
            Pen pen,
            float x,
            float y,
            float averageColumnWidth,
            float dotsPerLine,
            float tick)
        {
            if (tick >= this.rangeMinX &&
                tick <= (this.rangeMaxX + (this.rangeMaxX - this.rangeMinX) / 1000f))
            {
                float xPos = this.PlotX(x, averageColumnWidth, tick);
                g.DrawLine(pen, xPos, y, xPos, y + dotsPerLine / 8);
            }
        }

        private float MajorTick(
            Graphics g,
            Pen pen,
            Font regFont,
            Brush brush,
            float x,
            float y,
            float averageColumnWidth,
            float dotsPerLine,
            float tick,
            float minCutoff,
            float maxCutoff,
            bool suppressText)
        {
            string tickString = tick.ToString(this.labelFormat, CultureInfo.InvariantCulture);
            float width = g.MeasureString(tickString, regFont).Width;
            float xMid = this.PlotX(x, averageColumnWidth, tick);
            if (tick >= this.rangeMinX &&
                tick <= (this.rangeMaxX + (this.rangeMaxX - this.rangeMinX) / 1000f))
            {
                g.DrawLine(pen, xMid, y, xMid, y + dotsPerLine / 2);
                if (minCutoff < xMid - width / 2 &&
                    maxCutoff > xMid + width / 2 &&
                    !suppressText)
                {
                    g.DrawString(
                        tickString,
                        regFont,
                        brush,
                        xMid - width / 2,
                        y + 0.6f * dotsPerLine);
                }
            }
            return width;
        }

        private void InitData(string text)
        {
            this.headers.Clear();
            this.rows.Clear();
            this.verticalLines.Clear();
            this.columnInches.Clear();

            this.rangeScale = RangeScale.None;

            this.averageColumn = -1;
            this.lowerColumn = -1;
            this.upperColumn = -1;
            this.groupColumn = -1;
            this.optionsColumn = -1;

            this.screenDpi = 96;
            this.screenAntialias = true;
            this.screenColor = true;
            this.printerDpi = 600;
            this.printerAntialias = false;
            this.printerColor = false;
            this.rangeMinX = 0.0f;
            this.rangeMaxX = 1.0f;
            this.labelMin = EndLabel.Auto;
            this.labelMax = EndLabel.Auto;
            this.labelFormat = "G7";
            this.averageAlignX = 0.0f;
            this.lowerAlignX = 0.0f;
            this.upperAlignX = 0.0f;
            this.tickIntervalX = 0.0f;
            this.labelIntervalX = 0.0f;
            this.penPoints = 1.0f;
            this.barPenPoints = 1.0f;
            this.arrowPoints = 4.0f;
            this.backColor = 0xffffff;
            this.foreColor = 0x000000;
            this.headerColor = -1;
            this.labelColor = -1;
            this.label = "";
            this.fontName = "Verdana";
            this.fontPoints = 12.0f;
            this.rowLines = 1.5f;
            this.headerRowLines = 1.5f;
            this.leftMarginInches = 0.1f;
            this.rightMarginInches = 0.1f;
            this.topMarginInches = 0.1f;
            this.bottomMarginInches = 0.1f;
            this.backgroundLeftMarginInches = 0.0f;
            this.backgroundRightMarginInches = 0.0f;
            this.backgroundTopMarginLines = 0.0f;

            this.dataText = text;
            this.errorMessage = "";

            string parserContext = null;
            bool rangeMinSpecified = false;
            bool rangeMaxSpecified = false;
            bool lowerAlignSpecified = false;
            bool averageAlignSpecified = false;
            bool upperAlignSpecified = false;

            try
            {
                var lines = this.dataText.Split(lineBreakChars, StringSplitOptions.RemoveEmptyEntries);
                foreach (var line in lines)
                {
                    var parts = ParseLine(line);
                    if (parts == null)
                    {
                        // Comment.
                        continue;
                    }
                    else if (parts[0] != null)
                    {
                        parserContext = line;
                        switch (parts[0].ToLowerInvariant())
                        {
                            case "verticalline":
                                var part1 = parts[1];

                                var dashStyle = DashStyle.Solid;
                                var semicolon = part1.IndexOf(';');
                                if (semicolon >= 0)
                                {
                                    switch (part1.Substring(semicolon + 1).ToLowerInvariant())
                                    {
                                        case "dash":
                                            dashStyle = DashStyle.Dash;
                                            break;
                                        case "dashdot":
                                            dashStyle = DashStyle.DashDot;
                                            break;
                                        case "dashdotdot":
                                            dashStyle = DashStyle.DashDotDot;
                                            break;
                                        case "dot":
                                            dashStyle = DashStyle.Dot;
                                            break;
                                    }

                                    part1 = part1.Substring(0, semicolon);
                                }

                                if (part1.Length != 0 && part1[0] == '+')
                                {
                                    this.verticalLines.Add(new VerticalLine(ParseFloat(part1.Substring(1), 0), true, dashStyle));
                                }
                                else
                                {
                                    this.verticalLines.Add(new VerticalLine(ParseFloat(part1, 0), false, dashStyle));
                                }
                                break;
                            case "columnwidth":
                                this.columnInches.Add(ParseFloat(parts[1], 0));
                                break;

                            case "averagecolumn":
                                this.averageColumn = ParseInt(parts[1], this.averageColumn);
                                break;
                            case "lowercolumn":
                                this.lowerColumn = ParseInt(parts[1], this.lowerColumn);
                                break;
                            case "uppercolumn":
                                this.upperColumn = ParseInt(parts[1], this.upperColumn);
                                break;
                            case "groupcolumn":
                                this.groupColumn = ParseInt(parts[1], this.groupColumn);
                                break;
                            case "optionscolumn":
                                this.optionsColumn = ParseInt(parts[1], this.optionsColumn);
                                break;

                            case "screendpi":
                                this.screenDpi = ParseInt(parts[1], this.screenDpi);
                                break;
                            case "screenantialias":
                                this.screenAntialias = ParseBool(parts[1], this.screenAntialias);
                                break;
                            case "screencolor":
                                this.screenColor = ParseBool(parts[1], this.screenColor);
                                break;
                            case "printerdpi":
                            case "imagedpi": // "imagedpi" is deprecated, back-compat only.
                                this.printerDpi = ParseInt(parts[1], this.printerDpi);
                                break;
                            case "printerantialias":
                            case "imageantialias": // "imageantialias" is deprecated, back-compat only.
                                this.printerAntialias = ParseBool(parts[1], this.printerAntialias);
                                break;
                            case "printercolor":
                            case "imagecolor": // "imagecolor" is deprecated, back-compat only.
                                this.printerColor = ParseBool(parts[1], this.printerColor);
                                break;
                            case "rangescale":
                                if (!string.IsNullOrEmpty(parts[1]))
                                {
                                    switch (parts[1].ToLowerInvariant())
                                    {
                                        case "log":
                                        case "logarithm":
                                        case "logarithmic":
                                        case "ratio":
                                            this.rangeScale = RangeScale.Log;
                                            break;
                                        case "normal":
                                        case "linear":
                                        case "default":
                                            this.rangeScale = RangeScale.Linear;
                                            break;
                                        default:
                                            throw new Exception("RangeScale must be linear or log.");
                                    }
                                }
                                break;
                            case "labelmin":
                            case "labelmax":
                                if (!string.IsNullOrEmpty(parts[1]))
                                {
                                    EndLabel endLabel;
                                    switch (parts[1].ToLowerInvariant())
                                    {
                                        case "default":
                                        case "auto":
                                            endLabel = EndLabel.Auto;
                                            break;
                                        case "end":
                                            endLabel = EndLabel.End;
                                            break;
                                        case "interval":
                                            endLabel = EndLabel.Interval;
                                            break;
                                        case "both":
                                            endLabel = EndLabel.Both;
                                            break;
                                        default:
                                            throw new Exception(parts[0] + " must be auto, end, normal, or both.");
                                    }
                                    if (parts[0].Equals("labelmin", StringComparison.OrdinalIgnoreCase))
                                    {
                                        this.labelMin = endLabel;
                                    }
                                    else
                                    {
                                        this.labelMax = endLabel;
                                    }
                                }
                                break;
                            case "labelformat":
                                if (!string.IsNullOrEmpty(parts[1]))
                                {
                                    this.labelFormat = parts[1];
                                }
                                break;
                            case "rangemin":
                                if (!string.IsNullOrEmpty(parts[1]))
                                {
                                    this.rangeMinX = ParseFloat(parts[1], this.rangeMinX);
                                    rangeMinSpecified = true;
                                }
                                break;
                            case "rangemax":
                                if (!string.IsNullOrEmpty(parts[1]))
                                {
                                    this.rangeMaxX = ParseFloat(parts[1], this.rangeMaxX);
                                    rangeMaxSpecified = true;
                                }
                                break;
                            case "averagealign":
                                if (!string.IsNullOrEmpty(parts[1]))
                                {
                                    this.averageAlignX = ParseFloat(parts[1], this.averageAlignX);
                                    averageAlignSpecified = true;
                                }
                                break;
                            case "loweralign":
                                if (!string.IsNullOrEmpty(parts[1]))
                                {
                                    this.lowerAlignX = ParseFloat(parts[1], this.lowerAlignX);
                                    lowerAlignSpecified = true;
                                }
                                break;
                            case "upperalign":
                                if (!string.IsNullOrEmpty(parts[1]))
                                {
                                    this.upperAlignX = ParseFloat(parts[1], this.upperAlignX);
                                    upperAlignSpecified = true;
                                }
                                break;
                            case "tickinterval":
                                this.tickIntervalX = ParseFloat(parts[1], this.tickIntervalX);
                                break;
                            case "labelinterval":
                                this.labelIntervalX = ParseFloat(parts[1], this.labelIntervalX);
                                break;
                            case "penwidth":
                                this.penPoints = ParseFloat(parts[1], this.penPoints);
                                break;
                            case "barpenwidth":
                                this.barPenPoints = ParseFloat(parts[1], this.barPenPoints);
                                break;
                            case "arrowsize":
                                this.arrowPoints = ParseFloat(parts[1], this.arrowPoints);
                                break;
                            case "background":
                            case "backgroundcolor":
                            case "bgcolor":
                                this.backColor = ParseRgb(parts[1], this.backColor);
                                break;
                            case "foreground":
                            case "foregroundcolor":
                            case "fgcolor":
                                this.foreColor = ParseRgb(parts[1], this.foreColor);
                                break;
                            case "headercolor":
                                this.headerColor = ParseRgb(parts[1], this.headerColor);
                                break;
                            case "labelcolor":
                                this.labelColor = ParseRgb(parts[1], this.labelColor);
                                break;
                            case "label":
                                this.label = ParseString(parts[1], this.label);
                                break;
                            case "fontname":
                                this.fontName = ParseString(parts[1], this.fontName);
                                break;
                            case "fontsize":
                                this.fontPoints = ParseFloat(parts[1], this.fontPoints); ;
                                break;
                            case "rowheight":
                                this.rowLines = ParseFloat(parts[1], this.rowLines);
                                break;
                            case "headerrowheight":
                                this.headerRowLines = ParseFloat(parts[1], this.headerRowLines);
                                break;
                            case "leftmargin":
                            case "lmargin":
                                this.leftMarginInches = ParseFloat(parts[1], this.leftMarginInches);
                                break;
                            case "rightmargin":
                            case "rmargin":
                                this.rightMarginInches = ParseFloat(parts[1], this.rightMarginInches);
                                break;
                            case "topmargin":
                            case "tmargin":
                                this.topMarginInches = ParseFloat(parts[1], this.topMarginInches);
                                break;
                            case "bottommargin":
                            case "bmargin":
                                this.bottomMarginInches = ParseFloat(parts[1], this.bottomMarginInches);
                                break;
                            case "backgroundleftmargin":
                            case "bglmargin":
                                this.backgroundLeftMarginInches = ParseFloat(parts[1], this.backgroundLeftMarginInches);
                                break;
                            case "backgroundrightmargin":
                            case "bgrmargin":
                                this.backgroundRightMarginInches = ParseFloat(parts[1], this.backgroundRightMarginInches);
                                break;
                            case "backgroundtopmargin":
                            case "bgtmargin":
                                this.backgroundTopMarginLines = ParseFloat(parts[1], this.backgroundTopMarginLines);
                                break;

                            default:
                                this.errorMessage = "Invalid setting name: " + parts[0];
                                break;
                        }

                        parserContext = null;
                    }
                    else
                    {
                        if (this.headers.Count == 0)
                        {
                            for (int i = 1; i < parts.Length; i++)
                            {
                                this.headers.Add(parts[i]);
                            }
                        }
                        else
                        {
                            var row = new Row(this.headers.Count, this.backColor, this.foreColor);
                            for (int i = 0; i < this.headers.Count; i++)
                            {
                                if (i + 1 < parts.Length)
                                {
                                    row.Cells[i] = parts[i + 1];
                                }
                                else
                                {
                                    row.Cells[i] = "";
                                }
                            }

                            this.rows.Add(row);
                        }
                    }
                }

                if (this.averageColumn < 0)
                {
                    this.errorMessage = "AverageColumn is not set.";
                }
                else if (this.averageColumn >= this.headers.Count)
                {
                    this.errorMessage = "AverageColumn is too big.";
                }
                else if (this.lowerColumn < 0)
                {
                    this.errorMessage = "LowerColumn is not set.";
                }
                else if (this.lowerColumn >= this.headers.Count)
                {
                    this.errorMessage = "LowerColumn is too big.";
                }
                else if (this.upperColumn < 0)
                {
                    this.errorMessage = "UpperColumn is not set.";
                }
                else if (this.upperColumn >= this.headers.Count)
                {
                    this.errorMessage = "UpperColumn is too big.";
                }
                else if (this.groupColumn >= this.headers.Count)
                {
                    this.errorMessage = "GroupColumn is too big.";
                }
                else if (this.optionsColumn >= this.headers.Count)
                {
                    this.errorMessage = "OptionsColumn is too big.";
                }
                else if (this.screenDpi < 30)
                {
                    this.errorMessage = "ScreenDpi is too small (less than 30).";
                }
                else if (this.screenDpi > 12000)
                {
                    this.errorMessage = "ScreenDpi is too big (bigger than 12000).";
                }
                else if (this.printerDpi < 30)
                {
                    this.errorMessage = "PrinterDpi is too small (less than 30).";
                }
                else if (this.printerDpi > 12000)
                {
                    this.errorMessage = "PrinterDpi is too big (bigger than 12000).";
                }
                else if (rangeMinSpecified && rangeMaxSpecified && this.rangeMaxX <= this.rangeMinX)
                {
                    this.errorMessage = "RangeMin must be less than RangeMax.";
                }
                else if (this.rangeScale != RangeScale.Log && this.tickIntervalX < 0)
                {
                    this.errorMessage = "Invalid TickInterval (must be greater than 0 for linear scale).";
                }
                else if (this.rangeScale == RangeScale.Log && this.tickIntervalX != 0 && this.tickIntervalX < 2)
                {
                    this.errorMessage = "Invalid TickInterval (must be 2 or greater for log scale).";
                }
                else if (this.rangeScale != RangeScale.Log && this.labelIntervalX < 0)
                {
                    this.errorMessage = "Invalid LabelInterval (must be greater than 0 for linear scale).";
                }
                else if (this.rangeScale == RangeScale.Log && this.labelIntervalX != 0 && this.labelIntervalX <= 1.0)
                {
                    this.errorMessage = "Invalid LabelInterval (must be greater than 1 for log scale).";
                }
                else if (this.penPoints < 0.5 || this.penPoints > 20)
                {
                    this.errorMessage = "Invalid PenWidth (must be between 0.5 and 20).";
                }
                else if (this.barPenPoints < 0.5 || this.barPenPoints > 20)
                {
                    this.errorMessage = "Invalid BarPenWidth (must be between 0.5 and 20).";
                }
                else if (this.arrowPoints < 0 || this.arrowPoints > 20)
                {
                    this.errorMessage = "Invalid ArrowSize (must be between 0 and 20).";
                }
                else if (this.fontPoints > 180 || this.fontPoints < 6)
                {
                    this.errorMessage = "Invalid FontSize (must be between 6 an 180).";
                }
                else if (this.rowLines < 1)
                {
                    this.errorMessage = "Invalid RowHeight (must not be less than 1).";
                }
                else if (this.headerRowLines < 1)
                {
                    this.errorMessage = "Invalid HeaderRowHeight (must not be less than 1).";
                }
                else if (this.rangeScale == RangeScale.Log)
                {
                    if (rangeMinSpecified && this.rangeMinX <= 0)
                    {
                        this.errorMessage = "Invalid RangeMin for log scale - must be greater than 0.";
                    }
                }

                if (string.IsNullOrEmpty(this.errorMessage))
                {
                    parserContext = null;
                    for (int i = 0; i < this.rows.Count; i++)
                    {
                        parserContext = "Data from row " + i.ToString();
                        var row = this.rows[i];

                        if (this.optionsColumn >= 0)
                        {
                            parserContext = "Options from row " + i.ToString();
                            var opts = row.Cells[this.optionsColumn].Split(optionsSplitChars, StringSplitOptions.RemoveEmptyEntries);
                            foreach (var opt in opts)
                            {
                                var parts = opt.Split(optionPartSplitChars, StringSplitOptions.RemoveEmptyEntries);
                                switch (parts[0].ToLowerInvariant())
                                {
                                    case "diamond":
                                        row.Diamond = true;
                                        break;
                                    case "bold":
                                        row.Bold = true;
                                        break;
                                    case "dash":
                                        row.Dash = true;
                                        break;
                                    case "summary":
                                        row.Diamond = true;
                                        row.Bold = true;
                                        row.Dash = true;
                                        break;
                                    case "groupstart":
                                    case "gs":
                                        row.GroupStart = true;
                                        break;
                                    case "groupend":
                                    case "ge":
                                        row.GroupEnd = true;
                                        break;
                                    case "background":
                                    case "bg":
                                        if (parts.Length == 2)
                                        {
                                            row.BackColor = ParseRgb(parts[1], row.BackColor);
                                        }
                                        break;
                                    case "foreground":
                                    case "fg":
                                        if (parts.Length == 2)
                                        {
                                            row.ForeColor = ParseRgb(parts[1], row.ForeColor);
                                        }
                                        break;
                                    case "skip":
                                        row.Skip = true;
                                        break;
                                }
                            }
                        }

                        if (!row.Skip)
                        {
                            row.Average = float.Parse(row.Cells[this.averageColumn], CultureInfo.InvariantCulture);
                            row.Lower = float.Parse(row.Cells[this.lowerColumn], CultureInfo.InvariantCulture);
                            row.Upper = float.Parse(row.Cells[this.upperColumn], CultureInfo.InvariantCulture);
                        }
                    }

                    parserContext = null;

                    this.columnInches.Capacity = this.headers.Count;

                    for (int i = 0; i < this.headers.Count; i++)
                    {
                        while (this.columnInches.Count <= i)
                        {
                            this.columnInches.Add(0);
                        }
                    }
                }

                if (this.rangeScale == RangeScale.None)
                {
                    this.rangeScale = RangeScale.Linear;
                }

                if (this.rows.Count != 0)
                {
                    float min = this.rows[0].Min;
                    float max = this.rows[0].Max;
                    for (int i = 1; i < this.rows.Count; i++)
                    {
                        min = Math.Min(min, this.rows[i].Min);
                        max = Math.Max(max, this.rows[i].Max);
                    }

                    if (!rangeMinSpecified)
                    {
                        this.rangeMinX = min;
                    }

                    if (!rangeMaxSpecified)
                    {
                        this.rangeMaxX = max;
                    }
                }

                if (this.rangeScale == RangeScale.Log)
                {
                    if (!lowerAlignSpecified) this.lowerAlignX = 1.0f;
                    if (!averageAlignSpecified) this.averageAlignX = 1.0f;
                    if (!upperAlignSpecified) this.upperAlignX = 1.0f;
                }

                if (this.rangeMinX >= this.rangeMaxX)
                {
                    throw new Exception(
                        "RangeMin (" + this.rangeMinX.ToString() + ") " +
                        "is not less than RangeMax (" + this.rangeMaxX.ToString() + ").");
                }
                else if (this.rangeScale == RangeScale.Log && this.rangeMinX <= 0)
                {
                    throw new Exception(
                        "RangeMin is " + this.rangeMinX.ToString() + ", but it " +
                        " must be greater than 0 for Log (ratio) charts.");
                }
                else if (this.averageAlignX < this.rangeMinX)
                {
                    this.errorMessage = "AverageAlign is too low.";
                }
                else if (this.averageAlignX > this.rangeMaxX)
                {
                    this.errorMessage = "AverageAlign is too high.";
                }
                else if (this.lowerAlignX < this.rangeMinX)
                {
                    this.errorMessage = "LowerAlign is too low.";
                }
                else if (this.lowerAlignX > this.rangeMaxX)
                {
                    this.errorMessage = "LowerAlign is too high.";
                }
                else if (this.upperAlignX < this.rangeMinX)
                {
                    this.errorMessage = "UpperAlign is too low.";
                }
                else if (this.upperAlignX > this.rangeMaxX)
                {
                    this.errorMessage = "UpperAlign is too high.";
                }

                if (this.headerColor == -1)
                {
                    this.headerColor = this.foreColor;
                }

                if (this.labelColor == -1)
                {
                    this.labelColor = this.foreColor;
                }
            }
            catch (Exception ex)
            {
                if (Program.ExceptionIsDangerous(ex))
                {
                    throw;
                }

                if (parserContext == null)
                {
                    this.errorMessage = ex.Message;
                }
                else
                {
                    this.errorMessage = "Error parsing " + parserContext + "\r\n" + ex.Message;
                }
            }
        }

        private float PlotX(float plotLeft, float plotWidth, float x)
        {
            if (x < this.rangeMinX)
            {
                x = this.rangeMinX;
            }
            else if (x > this.rangeMaxX)
            {
                x = this.rangeMaxX;
            }

            float pos;
            if (this.rangeScale == RangeScale.Log)
            {
                pos = (float)(Math.Log(x / this.rangeMinX) / Math.Log(this.rangeMaxX / this.rangeMinX));
            }
            else
            {
                pos = (x - this.rangeMinX) / (this.rangeMaxX - this.rangeMinX);
            }

            return plotLeft + plotWidth * pos;
        }

        private static Color PickColor(int rgb, bool color)
        {
            int rgbOrGray = color
                ? rgb
                : (((rgb & 0xff) + ((rgb >> 8) & 0xff) + ((rgb >> 16) & 0xff)) / 3) * 0x010101;
            Color result = Color.FromArgb(rgbOrGray | Opaque);
            return result;
        }

        private static int ParseRgb(string part, int def)
        {
            int rgb = string.IsNullOrEmpty(part)
                ? def
                : int.Parse(part, NumberStyles.HexNumber, CultureInfo.InvariantCulture);
            return rgb;
        }

        private static float ParseFloat(string part, float def)
        {
            return string.IsNullOrEmpty(part)
                ? def
                : float.Parse(part, CultureInfo.InvariantCulture);
        }

        private static int ParseInt(string part, int def)
        {
            return string.IsNullOrEmpty(part)
                ? def
                : int.Parse(part, CultureInfo.InvariantCulture);
        }

        private static bool ParseBool(string part, bool def)
        {
            char ch = string.IsNullOrEmpty(part)
                ? (def ? '1' : '0')
                : char.ToUpperInvariant(part[0]);
            return ch != '0' && ch != 'N' && ch != 'F';
        }

        private static string ParseString(string part, string def)
        {
            return string.IsNullOrEmpty(part) ? def : part;
        }

        private static string[] ParseLine(string line)
        {
            if (line.StartsWith(";", StringComparison.Ordinal))
            {
                return null;
            }

            bool blank = true;
            StringBuilder sb = new StringBuilder();            
            var parts = new List<string>();
            parts.Add(null);
            bool quoted = false;
            for (int i = 0; i < line.Length; i++)
            {
                char ch = line[i];
                if (ch == '"')
                {
                    if (quoted)
                    {
                        if (i + 1 < line.Length && line[i + 1] == '"')
                        {
                            sb.Append('"');
                            i++;
                        }
                        else
                        {
                            quoted = false;
                        }
                    }
                    else
                    {
                        quoted = true;
                    }
                }
                else if (ch == '\\' && i + 1 < line.Length)
                {
                    i++;
                    ch = line[i];
                    switch (ch)
                    {
                        case 'r':
                        case 'n':
                            sb.Append("\r\n");
                            break;
                        case '\\':
                            sb.Append('\\');
                            break;
                        case '1':
                            sb.Append('¹');
                            break;
                        case '2':
                            sb.Append('²');
                            break;
                        case '3':
                            sb.Append('³');
                            break;
                        case 'S':
                            if (i + 1 < line.Length)
                            {
                                i++;
                                ch = line[i];
                                switch (ch)
                                {
                                    case '0':
                                        sb.Append('⁰');
                                        break;
                                    case '1':
                                        sb.Append('¹');
                                        break;
                                    case '2':
                                        sb.Append('²');
                                        break;
                                    case '3':
                                        sb.Append('³');
                                        break;
                                    case '4':
                                        sb.Append('⁴');
                                        break;
                                    case '5':
                                        sb.Append('⁵');
                                        break;
                                    case '6':
                                        sb.Append('⁶');
                                        break;
                                    case '7':
                                        sb.Append('⁷');
                                        break;
                                    case '8':
                                        sb.Append('⁸');
                                        break;
                                    case '9':
                                        sb.Append('⁹');
                                        break;
                                    case '+':
                                        sb.Append('⁺');
                                        break;
                                    case '-':
                                        sb.Append('⁻');
                                        break;
                                    case '=':
                                        sb.Append('⁼');
                                        break;
                                    case '(':
                                        sb.Append('⁽');
                                        break;
                                    case ')':
                                        sb.Append('⁾');
                                        break;
                                    case 'a':
                                        sb.Append('ᵃ');
                                        break;
                                    case 'b':
                                        sb.Append('ᵇ');
                                        break;
                                    case 'c':
                                        sb.Append('ᶜ');
                                        break;
                                    case 'd':
                                        sb.Append('ᵈ');
                                        break;
                                    case 'e':
                                        sb.Append('ᵉ');
                                        break;
                                    case 'f':
                                        sb.Append('ᶠ');
                                        break;
                                    case 'g':
                                        sb.Append('ᵍ');
                                        break;
                                    case 'h':
                                        sb.Append('ʰ');
                                        break;
                                    case 'i':
                                        sb.Append('ⁱ');
                                        break;
                                    case 'j':
                                        sb.Append('ʲ');
                                        break;
                                    case 'k':
                                        sb.Append('ᵏ');
                                        break;
                                    case 'l':
                                        sb.Append('ˡ');
                                        break;
                                    case 'm':
                                        sb.Append('ᵐ');
                                        break;
                                    case 'n':
                                        sb.Append('ⁿ');
                                        break;
                                    case 'o':
                                        sb.Append('ᵒ');
                                        break;
                                    case 'p':
                                        sb.Append('ᵖ');
                                        break;
                                    case 'r':
                                        sb.Append('ʳ');
                                        break;
                                    case 's':
                                        sb.Append('ˢ');
                                        break;
                                    case 't':
                                        sb.Append('ᵗ');
                                        break;
                                    case 'u':
                                        sb.Append('ᵘ');
                                        break;
                                    case 'v':
                                        sb.Append('ᵛ');
                                        break;
                                    case 'w':
                                        sb.Append('ʷ');
                                        break;
                                    case 'x':
                                        sb.Append('ˣ');
                                        break;
                                    case 'y':
                                        sb.Append('ʸ');
                                        break;
                                    case 'z':
                                        sb.Append('ᶻ');
                                        break;
                                    case 'A':
                                        sb.Append('ᴬ');
                                        break;
                                    case 'B':
                                        sb.Append('ᴮ');
                                        break;
                                    case 'D':
                                        sb.Append('ᴰ');
                                        break;
                                    case 'E':
                                        sb.Append('ᴱ');
                                        break;
                                    case 'G':
                                        sb.Append('ᴳ');
                                        break;
                                    case 'H':
                                        sb.Append('ᴴ');
                                        break;
                                    case 'I':
                                        sb.Append('ᴵ');
                                        break;
                                    case 'J':
                                        sb.Append('ᴶ');
                                        break;
                                    case 'K':
                                        sb.Append('ᴷ');
                                        break;
                                    case 'L':
                                        sb.Append('ᴸ');
                                        break;
                                    case 'M':
                                        sb.Append('ᴹ');
                                        break;
                                    case 'N':
                                        sb.Append('ᴺ');
                                        break;
                                    case 'O':
                                        sb.Append('ᴼ');
                                        break;
                                    case 'P':
                                        sb.Append('ᴾ');
                                        break;
                                    case 'R':
                                        sb.Append('ᴿ');
                                        break;
                                    case 'T':
                                        sb.Append('ᵀ');
                                        break;
                                    case 'U':
                                        sb.Append('ᵁ');
                                        break;
                                    case 'V':
                                        sb.Append('ⱽ');
                                        break;
                                    case 'W':
                                        sb.Append('ᵂ');
                                        break;
                                    default:
                                        sb.Append("(Backslash-S");
                                        sb.Append(ch);
                                        sb.Append(')');
                                        break;
                                }
                            }
                            else
                            {
                                sb.Append("(Backslash-S)");
                            }
                            break;
                        default:
                            sb.Append("(Backslash-");
                            sb.Append(ch);
                            sb.Append(')');
                            break;
                    }
                }
                else if (ch == ',' && !quoted)
                {
                    if (sb.Length > 0)
                    {
                        blank = false;
                    }

                    parts.Add(sb.ToString());
                    sb.Length = 0;
                }
                else if (parts.Count == 1 && parts[0] == null && !quoted && ch == '=')
                {
                    if (sb.Length > 0)
                    {
                        blank = false;
                    }

                    parts[0] = sb.ToString();
                    sb.Length = 0;
                }
                else
                {
                    sb.Append(ch);
                }
            }

            if (sb.Length > 0)
            {
                blank = false;
            }

            parts.Add(sb.ToString());
            return blank ? null : parts.ToArray();
        }

        private struct VerticalLine
        {
            public readonly float X;
            public readonly bool Extend; // Extend into column headings?
            public readonly DashStyle DashStyle;

            public VerticalLine(float x, bool extend, DashStyle dashStyle)
            {
                this.X = x;
                this.Extend = extend;
                this.DashStyle = dashStyle;
            }
        }

        private struct Diamond
        {
            public readonly Row Row;
            public readonly PointF[] Points;

            public Diamond(Row row, float x, float y, float size)
            {
                this.Row = row;
                this.Points = new PointF[] {
                    new PointF(x - size / 2, y + size),
                    new PointF(x, y),
                    new PointF(x + size / 2, y + size),
                    new PointF(x, y + size * 2)
                };
            }
        }

        private class Row
        {
            public readonly string[] Cells;
            public int BackColor;
            public int ForeColor;
            public float Average;
            public float Lower;
            public float Upper;
            public bool GroupStart;
            public bool GroupEnd;
            public bool Diamond;
            public bool Bold;
            public bool Dash;
            public bool Skip;

            public Row(int cellCount, int backColor, int foreColor)
            {
                this.Cells = new string[cellCount];
                this.BackColor = backColor;
                this.ForeColor = foreColor;
            }

            public float Max
            {
                get
                {
                    if (this.Upper > this.Lower)
                    {
                        if (this.Upper > this.Average)
                        {
                            return this.Upper;
                        }
                        else
                        {
                            return this.Average;
                        }
                    }
                    else
                    {
                        if (this.Lower > this.Average)
                        {
                            return this.Lower;
                        }
                        else
                        {
                            return this.Average;
                        }
                    }
                }
            }

            public float Min
            {
                get
                {
                    if (this.Upper < this.Lower)
                    {
                        if (this.Upper < this.Average)
                        {
                            return this.Upper;
                        }
                        else
                        {
                            return this.Average;
                        }
                    }
                    else
                    {
                        if (this.Lower < this.Average)
                        {
                            return this.Lower;
                        }
                        else
                        {
                            return this.Average;
                        }
                    }
                }
            }
        }
    }
}