/// <summary>
        ///  translates TextSymbol enum value to unicode character
        /// </summary>
        /// <param name="symbol">enum representation</param>
        /// <returns>unicode character</returns>
        /// <remarks>refers to: http://www.decodeunicode.org/ (f.e.)</remarks>
        public static string TranslateSymbol(TextSymbols symbol)
        {
            #region symbol matching
            switch (symbol)
            {
            case TextSymbols.alpha:
                return("α");

            case TextSymbols.beta:
                return("β");

            case TextSymbols.gamma:
                return("γ");

            case TextSymbols.delta:
                return("δ");

            case TextSymbols.epsilon:
                return("ε");

            case TextSymbols.zeta:
                return("ζ");

            case TextSymbols.eta:
                return("η");

            case TextSymbols.theta:
                return("θ");

            case TextSymbols.vartheta:
                return("\u03d1");

            case TextSymbols.iota:
                return("ι");

            case TextSymbols.kappa:
                return("κ");

            case TextSymbols.lambda:
                return("λ");

            case TextSymbols.mu:
                return("μ");

            case TextSymbols.nu:
                return("ν");

            case TextSymbols.xi:
                return("ξ");

            case TextSymbols.pi:
                return("π");

            case TextSymbols.rho:
                return("ρ");

            case TextSymbols.sigma:
                return("σ");

            case TextSymbols.varsigma:
                return("ς");

            case TextSymbols.tau:
                return("τ");

            case TextSymbols.upsilon:
                return("υ");

            case TextSymbols.phi:
                return("φ");

            case TextSymbols.chi:
                return("χ");

            case TextSymbols.psi:
                return("ψ");

            case TextSymbols.omega:
                return("ω");

            case TextSymbols.Gamma:
                return("Γ");

            case TextSymbols.Delta:
                return("Δ");

            case TextSymbols.Theta:
                return("Θ");

            case TextSymbols.Lambda:
                return("Λ");

            case TextSymbols.Xi:
                return("Ξ");

            case TextSymbols.Pi:
                return("\u03a0");    //"Π";

            case TextSymbols.Sigma:
                return("Σ");

            case TextSymbols.Upsilon:
                return("Υ");

            case TextSymbols.Phi:
                return("Φ");

            case TextSymbols.Psi:
                return("Ψ");

            case TextSymbols.Omega:
                return("Ω");

            case TextSymbols.forall:
                return("\u2200");

            case TextSymbols.exists:
                return("\u2203");

            case TextSymbols.ni:
                return("\u220b");

            case TextSymbols.cong:
                return("\u2205");

            case TextSymbols.neq:
                return("\u2260");

            case TextSymbols.equiv:
                return("\u2261");

            case TextSymbols.approx:
                return("\u2240");

            case TextSymbols.aleph:
                return("\u2235");

            case TextSymbols.Im:
                return("\u2111");

            case TextSymbols.Re:
                return("\u211b");

            case TextSymbols.wp:
                return("\u2118");

            case TextSymbols.otimes:
                return("\u2297");

            case TextSymbols.oplus:
                return("\u2295");

            case TextSymbols.oslash:
                return("\u2205");

            case TextSymbols.cap:
                return("\u22c2");

            case TextSymbols.cup:
                return("\u22c3");

            case TextSymbols.supseteq:
                return("\u2287");

            case TextSymbols.supset:
                return("\u2283");

            case TextSymbols.subseteq:
                return("\u2286");

            case TextSymbols.subset:
                return("\u2282");

            case TextSymbols.int_:
                return("\u222b");

            case TextSymbols.in_:
                return("\u2208");

            case TextSymbols.o:
                return("\u25cb");

            case TextSymbols.rfloor:
                return("\u230b");

            case TextSymbols.lceil:
                return("\u2308");

            case TextSymbols.nabla:
                return("\u2207");

            case TextSymbols.lfloor:
                return("\u230a");

            case TextSymbols.cdot:
                return("\u2219");

            case TextSymbols.ldots:
                return("\u2026");

            case TextSymbols.cdots:
                return("\u220f");

            case TextSymbols.perp:
                return("\u22a5");

            case TextSymbols.neg:
                return("\u2511");

            case TextSymbols.prime:
                return("\u2032");

            case TextSymbols.wedge:
                return("\u22c0");

            case TextSymbols.times:
                return("\u2a09");

            case TextSymbols.Null:
                return("\u2205");

            case TextSymbols.rceil:
                return("\u2309");

            case TextSymbols.surd:
                return("\u221a");

            case TextSymbols.mid:
                return("|");

            case TextSymbols.vee:
                return("\u22c1");

            case TextSymbols.varpi:
                return("\u03d6");

            case TextSymbols.copyright:
                return("\u00a9");

            case TextSymbols.langle:
                return("\u2329");

            case TextSymbols.rangle:
                return("\u232a");

            case TextSymbols.sim:
                return("\u223c");

            case TextSymbols.leq:
                return("\u2264");

            case TextSymbols.infty:
                return("\u221e");

            case TextSymbols.leftrightarrow:
                return("\u21d4");

            case TextSymbols.leftarrow:
                return("\u21d0");

            case TextSymbols.uparrow:
                return("\u21d1");

            case TextSymbols.rightarrow:
                return("\u21d2");

            case TextSymbols.downarrow:
                return("\u21d3");

            case TextSymbols.circ:
                return("\u25cc");

            case TextSymbols.pm:
                return("\u00b1");

            case TextSymbols.geq:
                return("\u2265");

            case TextSymbols.propto:
                return("\u221d");

            case TextSymbols.partial:
                return("\u2202");

            case TextSymbols.div:
                return("\u00f7");

            default:
                break;
            }
            return("");

            #endregion
        }
        protected override void parseString(string expression, Font font, Point offset, Color color,
                                            IILTextRenderer renderer, ref Size size,
                                            ref List <ILRenderQueueItem> queue)
        {
            int        pos = 0;
            string     key, itemText;
            RectangleF bmpSize = new RectangleF();
            int        curHeigth = 0, curWidth = 0;
            Bitmap     itemBMP = null;
            int        lineHeight = 0, lineWidth = 0;
            Size       itemSize = Size.Empty;

            while (pos < expression.Length)
            {
                itemText = expression.Substring(pos++, 1);
                #region special position control sequences
                if (itemText == "\r")
                {
                    queue.Add(new ILRenderQueueItem(itemText, 0, 0, color));
                    if (curWidth < lineWidth)
                    {
                        curWidth = lineWidth;
                    }
                    lineWidth = 0;
                    continue;
                }
                else if (itemText == "\n")
                {
                    queue.Add(new ILRenderQueueItem(itemText, 0, 0, color));
                    curHeigth += lineHeight;
                    lineHeight = 0;
                    if (curWidth < lineWidth)
                    {
                        curWidth = lineWidth;
                    }
                    lineWidth = 0;
                    continue;
                    #endregion
                }
                else if (itemText == "\\")
                {
                    #region font control
                    if (pos < expression.Length - 2)
                    {
                        #region test for font control sequences: \it,\bf,\rm
                        if (expression[pos] == 'i' && expression[pos + 1] == 't')
                        {
                            font = new Font(font, font.Style | FontStyle.Italic);
                            pos += 2; continue;
                        }
                        else if (expression[pos] == 'b' && expression[pos + 1] == 'f')
                        {
                            font = new Font(font, font.Style | FontStyle.Bold);
                            pos += 2; continue;
                        }
                        else if (expression[pos] == 'r' && expression[pos + 1] == 'm')
                        {
                            font = new Font(font, FontStyle.Regular);
                            pos += 2; continue;
                        }
                        #endregion
                        #region fontname,-size,-color
                        if (parseKeyword(expression, ref pos, Keywords.Reset))
                        {
                            color  = Color.Empty;
                            font   = m_normalFont;
                            offset = new Point(0, 0);
                            continue;
                        }
                        string parameter = "";
                        if (parseKeywordArgumented(expression, ref pos, Keywords.Fontname, ref parameter))
                        {
                            font = new Font(parameter, font.Size, font.Style, font.Unit);
                            continue;
                        }
                        if (parseKeywordArgumented(expression, ref pos, Keywords.Fontsize, ref parameter))
                        {
                            int newSize;
                            if (!int.TryParse(parameter, out newSize))
                            {
                                continue;
                            }
                            if (parameter.StartsWith("+") && newSize > 0)
                            {
                                newSize += (int)font.Size;
                                if (newSize > 40)
                                {
                                    newSize = 40;
                                }
                            }
                            else if (parameter.StartsWith("-") && -newSize < font.Size)
                            {
                                newSize = (int)font.Size + newSize;
                            }
                            if (newSize > 0 && newSize < 40)
                            {
                                offset.Y += (int)Math.Round(font.Size - newSize);
                                font      = new Font(font.Name, newSize, font.Style, font.Unit);
                            }
                            continue;
                        }
                        if (parseKeywordArgumented(expression, ref pos, Keywords.Color, ref parameter))
                        {
                            parseColor(parameter, ref color);
                            continue;
                        }
                        #endregion
                    }
                    #endregion
                    //if (pos < expression.Length - "size".Length)
                    #region handle predefined symbols
                    TextSymbols symbol = matchSymbol(expression, ref pos);
                    if (symbol != TextSymbols.nothing)
                    {
                        itemText = TranslateSymbol(symbol);
                        if (String.IsNullOrEmpty(itemText))
                        {
                            continue;
                        }
                    }
                    #endregion
                    #region lower- upper indices
                }
                else if (pos < expression.Length && itemText == "_")
                {
                    int end;
                    if (pos < expression.Length - 1 && expression[pos] == '{')
                    {
                        pos++;
                        // find end brace & remove
                        end = expression.IndexOf('}', pos) - 1;
                        if (end > 0 && end < expression.Length)
                        {
                            parseString(
                                expression.Substring(pos, end - pos + 1),
                                new Font(font.Name, font.Size * 0.7f, font.Style, font.Unit),
                                new Point(offset.X, offset.Y + (int)(0.3f * font.Height)),
                                color, renderer, ref size, ref queue);
                            pos = end + 2;
                            continue;
                        }
                    }
                    // cache next char only
                    parseString(
                        expression.Substring(pos++, 1),
                        new Font(font.Name, font.Size * 0.7f, font.Style, font.Unit),
                        new Point(offset.X, offset.Y + (int)(0.3f * font.Height)),
                        color, renderer, ref size, ref queue);
                    continue;
                }
                else if (pos < expression.Length && itemText == "^")
                {
                    int end;
                    //offset.Y += 0.8f * font.Height;
                    if (pos < expression.Length - 1 && expression[pos] == '{')
                    {
                        pos++;
                        // find end brace & remove
                        end = expression.IndexOf('}', pos) - 1;
                        if (end > 0 && end < expression.Length)
                        {
                            parseString(
                                expression.Substring(pos, end - pos + 1),
                                new Font(font.Name, font.Size * 0.7f, font.Style, font.Unit),
                                new Point(offset.X, offset.Y - (int)(0.2f * font.Height)),
                                color, renderer, ref size, ref queue);
                            pos = end + 2;
                            continue;
                        }
                    }
                    // cache next char only
                    parseString(
                        expression.Substring(pos++, 1),
                        new Font(font.Name, font.Size * 0.7f, font.Style, font.Unit),
                        new Point(offset.X, offset.Y - (int)(0.2f * font.Height))
                        , color, renderer, ref size, ref queue);
                    continue;
                    #endregion
                }
                key = ILHashCreator.Hash(font, itemText);

                if (renderer.TryGetSize(key, ref itemSize))
                {
                    queue.Add(new ILRenderQueueItem(key, offset, color));
                    if (itemSize.Height > lineHeight)
                    {
                        lineHeight = itemSize.Height;
                    }
                    lineWidth += (int)itemSize.Width;
                }
                else
                {
                    lock (this) {
                        itemBMP = transformItem(itemText, font, out bmpSize);
                        renderer.Cache(key, itemBMP, bmpSize);
                        queue.Add(new ILRenderQueueItem(key, offset, color));
                        // update size
                        if (bmpSize.Height > lineHeight)
                        {
                            lineHeight = (int)bmpSize.Height;
                        }
                        lineWidth += (int)bmpSize.Width;
                    }
                }
            }
            size.Width += ((curWidth > lineWidth)?curWidth:lineWidth);
            size.Height = curHeigth + lineHeight;
        }
Пример #3
0
 /// <summary>
 ///  translates TextSymbol enum value to unicode character
 /// </summary>
 /// <param name="symbol">enum representation</param>
 /// <returns>unicode character</returns>
 /// <remarks>refers to: http://www.decodeunicode.org/ (f.e.)</remarks>
 public static string TranslateSymbol (TextSymbols symbol) {
     #region symbol matching
     switch (symbol) {
         case TextSymbols.alpha:
             return "α";
         case TextSymbols.beta:
             return "β";
         case TextSymbols.gamma:
             return "γ";
         case TextSymbols.delta:
             return "δ";
         case TextSymbols.epsilon:
             return "ε";
         case TextSymbols.zeta:
             return "ζ";
         case TextSymbols.eta:
             return "η";
         case TextSymbols.theta:
             return "θ";
         case TextSymbols.vartheta:
             return "\u03d1";
         case TextSymbols.iota:
             return "ι";
         case TextSymbols.kappa:
             return "κ";
         case TextSymbols.lambda:
             return "λ";
         case TextSymbols.mu:
             return "μ";
         case TextSymbols.nu:
             return "ν";
         case TextSymbols.xi:
             return "ξ";
         case TextSymbols.pi:
             return "π";
         case TextSymbols.rho:
             return "ρ";
         case TextSymbols.sigma:
             return "σ";
         case TextSymbols.varsigma:
             return "ς";
         case TextSymbols.tau:
             return "τ";
         case TextSymbols.upsilon:
             return "υ";
         case TextSymbols.phi:
             return "φ";
         case TextSymbols.chi:
             return "χ";
         case TextSymbols.psi:
             return "ψ";
         case TextSymbols.omega:
             return "ω";
         case TextSymbols.Gamma: 
             return "Γ"; 
         case TextSymbols.Delta:
             return "Δ";
         case TextSymbols.Theta:
             return "Θ";
         case TextSymbols.Lambda:
             return "Λ";
         case TextSymbols.Xi: 
             return "Ξ";
         case TextSymbols.Pi:
             return "\u03a0"; //"Π"; 
         case TextSymbols.Sigma:
             return "Σ";
         case TextSymbols.Upsilon:
             return "Υ";
         case TextSymbols.Phi:
             return "Φ";
         case TextSymbols.Psi:
             return "Ψ";
         case TextSymbols.Omega:
             return "Ω"; 
         case TextSymbols.forall:
             return "\u2200";
         case TextSymbols.exists:
             return "\u2203";  
         case TextSymbols.ni:
             return "\u220b"; 
         case TextSymbols.cong:
             return "\u2205"; 
         case TextSymbols.neq:
             return "\u2260"; 
         case TextSymbols.equiv:
             return "\u2261"; 
         case TextSymbols.approx:
             return "\u2240"; 
         case TextSymbols.aleph:
             return "\u2235"; 
         case TextSymbols.Im:
             return "\u2111"; 
         case TextSymbols.Re:
             return "\u211b"; 
         case TextSymbols.wp:
             return "\u2118"; 
         case TextSymbols.otimes:
             return "\u2297"; 
         case TextSymbols.oplus:
             return "\u2295"; 
         case TextSymbols.oslash:
             return "\u2205"; 
         case TextSymbols.cap:
             return "\u22c2"; 
         case TextSymbols.cup:
             return "\u22c3"; 
         case TextSymbols.supseteq:
             return "\u2287"; 
         case TextSymbols.supset:
             return "\u2283"; 
         case TextSymbols.subseteq:
             return "\u2286"; 
         case TextSymbols.subset:
             return "\u2282"; 
         case TextSymbols.int_:
             return "\u222b"; 
         case TextSymbols.in_:
             return "\u2208"; 
         case TextSymbols.o:
             return "\u25cb"; 
         case TextSymbols.rfloor:
             return "\u230b"; 
         case TextSymbols.lceil:
             return "\u2308"; 
         case TextSymbols.nabla:
             return "\u2207"; 
         case TextSymbols.lfloor:
             return "\u230a"; 
         case TextSymbols.cdot:
             return "\u2219"; 
         case TextSymbols.ldots:
             return "\u2026"; 
         case TextSymbols.cdots:
             return "\u220f"; 
         case TextSymbols.perp:
             return "\u22a5"; 
         case TextSymbols.neg:
             return "\u2511"; 
         case TextSymbols.prime:
             return "\u2032"; 
         case TextSymbols.wedge:
             return "\u22c0"; 
         case TextSymbols.times:
             return "\u2a09"; 
         case TextSymbols.Null:
             return "\u2205"; 
         case TextSymbols.rceil:
             return "\u2309"; 
         case TextSymbols.surd:
             return "\u221a"; 
         case TextSymbols.mid:
             return "|"; 
         case TextSymbols.vee:
             return "\u22c1"; 
         case TextSymbols.varpi:
             return "\u03d6"; 
         case TextSymbols.copyright:
             return "\u00a9"; 
         case TextSymbols.langle:
             return "\u2329"; 
         case TextSymbols.rangle:
             return "\u232a"; 
         case TextSymbols.sim: 
             return "\u223c"; 
         case TextSymbols.leq: 
             return "\u2264"; 
         case TextSymbols.infty: 
             return "\u221e"; 
         case TextSymbols.leftrightarrow: 
             return "\u21d4"; 
         case TextSymbols.leftarrow: 
             return "\u21d0"; 
         case TextSymbols.uparrow: 
             return "\u21d1"; 
         case TextSymbols.rightarrow: 
             return "\u21d2"; 
         case TextSymbols.downarrow:         
             return "\u21d3"; 
         case TextSymbols.circ: 
             return "\u25cc"; 
         case TextSymbols.pm: 
             return "\u00b1"; 
         case TextSymbols.geq: 
             return "\u2265"; 
         case TextSymbols.propto: 
             return "\u221d"; 
         case TextSymbols.partial: 
             return "\u2202"; 
         case TextSymbols.div: 
             return "\u00f7"; 
         default:
             break;
     }
     return ""; 
     #endregion
 }