using System;
using System.Collections.Generic;
using System.Xml;
using System.Drawing;
using System.Globalization;
using System.IO;
using System.Text;

using SMath.Manager;
using SMath.Controls;
using SMath.Drawing;

namespace XMCDFileType
{
    public class OpenSaveXMCD : IPluginOpenFileTypes, IPluginSaveFileTypes
    {
        private PrintPageModel globalpageModel = new PrintPageModel();
        private List<string> errStrings = new List<string>();
        private Settings mcadSettings = new Settings();

        #region XMCD file open methods

        private void OpenXMCD(FileContext context, XmlReader Reader, ref int errorsCount, ref int yAdd, RegionsList controls, Dictionary<string, string> binaryItems)
        {
            int regions = 0;
            List<string> globalVars = new List<string>();
            List<Styles> TextStyles = new List<Styles>();

            while (Reader.Read())
            {
                Reader.MoveToContent();
                if (Reader.NodeType == XmlNodeType.Element && (Reader.Name == "pointReleaseData" || Reader.Name == "metadata" || Reader.Name == "binaryContent"))
                {
                    Reader.Skip();
                }
                else if (Reader.NodeType == XmlNodeType.EndElement && (Reader.Name == "regions" || Reader.Name == "area"))
                {
                    regions--;
                    if (regions < 0)
                        return;
                    else
                        break;
                }
                //  added to read the styles from the settings element
                else if (Reader.Name == "settings")
                {
                    Styles style = new Styles();
                    string text = "";

                    if (Reader.NodeType == XmlNodeType.EndElement)
                        continue;

                    while (Reader.Read())
                    {
                        Reader.MoveToContent();
                        if (Reader.NodeType == XmlNodeType.EndElement && Reader.Name == "settings")
                            break;
                        if (Reader.NodeType == XmlNodeType.EndElement && Reader.Name == "textStyle")
                        {
                            TextStyles.Add(style);
                            style = new Styles();
                            continue;
                        }
                        if (Reader.NodeType == XmlNodeType.Element && Reader.Name == "textStyle")
                        {
                            style.name = Reader.GetAttribute("name");
                        }
                        if (Reader.NodeType == XmlNodeType.Element && Reader.Name == "inlineAttr")
                        {
                            style.fontfamily = Reader.GetAttribute("font-family");
                            Int32.TryParse(Reader.GetAttribute("font-size"), out style.fontsize);
                            if (Reader.GetAttribute("font-weight").ToLower() == "bold")
                                style.bold = true;
                            if (Reader.GetAttribute("font-style").ToLower() == "italic")
                                style.italics = true;
                            if (Reader.GetAttribute("underline").ToLower() == "true")
                                style.underline = true;
                        }
                        if (Reader.NodeType == XmlNodeType.Element && Reader.Name == "pageModel")
                        {
                            globalpageModel.width = Convert.ToInt16(Math.Floor(Convert.ToDouble(Reader.GetAttribute("page-width").Replace(GlobalProfile.DecimalSymbolStandard, GlobalProfile.DecimalSymbolSystem))));
                            globalpageModel.height = Convert.ToInt16(Math.Floor(Convert.ToDouble(Reader.GetAttribute("page-height").Replace(GlobalProfile.DecimalSymbolStandard, GlobalProfile.DecimalSymbolSystem))));
                            globalpageModel.paper_code = Reader.GetAttribute("paper-code");
                            globalpageModel.orientation = Reader.GetAttribute("orientation");
                        }
                        if (Reader.NodeType == XmlNodeType.Element && Reader.Name == "margins")
                        {
                            globalpageModel.margins.left = Convert.ToInt16(Math.Floor(Convert.ToDouble(Reader.GetAttribute("left").Replace(GlobalProfile.DecimalSymbolStandard, GlobalProfile.DecimalSymbolSystem))));
                            globalpageModel.margins.right = Convert.ToInt16(Math.Floor(Convert.ToDouble(Reader.GetAttribute("right").Replace(GlobalProfile.DecimalSymbolStandard, GlobalProfile.DecimalSymbolSystem))));
                            globalpageModel.margins.top = Convert.ToInt16(Math.Floor(Convert.ToDouble(Reader.GetAttribute("top").Replace(GlobalProfile.DecimalSymbolStandard, GlobalProfile.DecimalSymbolSystem))));
                            globalpageModel.margins.bottom = Convert.ToInt16(Math.Floor(Convert.ToDouble(Reader.GetAttribute("bottom").Replace(GlobalProfile.DecimalSymbolStandard, GlobalProfile.DecimalSymbolSystem))));
                        }
                        //
                        // For now I read and store this. If not saved as .xmcd this data is lost.
                        // Although I see "TheWizEd" is working on a "header/footer" region. Maybe I will be able to use that region for this data
                        // at some point in the future.
                        //
                        if (Reader.NodeType == XmlNodeType.Element && Reader.Name == "header" && !Reader.IsEmptyElement)
                        {
                            while (Reader.Read())
                            {
                                Reader.MoveToContent();
                                if (Reader.NodeType == XmlNodeType.EndElement && Reader.Name == "header")
                                    break;
                                if (Reader.Name == "footer")
                                    break;
                                if (Reader.NodeType == XmlNodeType.EndElement && Reader.Name == "left")
                                {
                                    globalpageModel.header.left = text;
                                    text = "";
                                    continue;
                                }
                                if (Reader.NodeType == XmlNodeType.EndElement && Reader.Name == "center")
                                {
                                    globalpageModel.header.center = text;
                                    text = "";
                                    continue;
                                }
                                if (Reader.NodeType == XmlNodeType.EndElement && Reader.Name == "right")
                                {
                                    globalpageModel.header.right = text;
                                    text = "";
                                    continue;
                                }
                                if (Reader.HasValue)
                                    text += Reader.Value;
                            }
                        }
                        if (Reader.NodeType == XmlNodeType.Element && Reader.Name == "footer" && !Reader.IsEmptyElement)
                        {
                            while (Reader.Read())
                            {
                                Reader.MoveToContent();
                                if (Reader.NodeType == XmlNodeType.EndElement && Reader.Name == "footer")
                                    break;
                                if (Reader.NodeType == XmlNodeType.EndElement && Reader.Name == "left")
                                {
                                    globalpageModel.footer.left = text;
                                    text = "";
                                    continue;
                                }
                                if (Reader.NodeType == XmlNodeType.EndElement && Reader.Name == "center")
                                {
                                    globalpageModel.footer.center = text;
                                    text = "";
                                    continue;
                                }
                                if (Reader.NodeType == XmlNodeType.EndElement && Reader.Name == "right")
                                {
                                    globalpageModel.footer.right = text;
                                    text = "";
                                    continue;
                                }
                                if (Reader.HasValue)
                                    text += Reader.Value;
                            }
                        }
                        if (Reader.NodeType == XmlNodeType.Element && Reader.Name == "colorModel")
                        {
                            text = Reader.GetAttribute("default-highlight-color");
                            if (text.Length == 7)
                                mcadSettings.defaultHighlightColor = text;
                            text = Reader.GetAttribute("background-color");
                            if (text.Length == 7)
                                mcadSettings.defaultBackgroundColor = text;
                        }
                    }
                }
                else if (Reader.NodeType == XmlNodeType.Element && Reader.Name == "region")
                {
                    regions++;

                    int
                        left,
                        top,
                        width,
                        height,
                        CLR2 = SMath.Drawing.Graphics.WebColorToColor(mcadSettings.defaultBackgroundColor);
                    bool
                        border,
                        highlight;
                    string
                        debug,
                        regionID = Reader.GetAttribute("region-id"),
                        bgcolor = "";

                    // changed 1.28 to 1.395 and then moved this value into a variable for easier use.
                    width = (int)(mcadSettings.scaleFactor * Convert.ToDouble(Reader.GetAttribute("width").Replace(GlobalProfile.DecimalSymbolStandard, GlobalProfile.DecimalSymbolSystem)));
                    height = (int)(mcadSettings.scaleFactor * Convert.ToDouble(Reader.GetAttribute("height").Replace(GlobalProfile.DecimalSymbolStandard, GlobalProfile.DecimalSymbolSystem)));
                    left = (int)(mcadSettings.scaleFactor * Convert.ToDouble(Reader.GetAttribute("left").Replace(GlobalProfile.DecimalSymbolStandard, GlobalProfile.DecimalSymbolSystem)));
                    top = (int)(mcadSettings.scaleFactor * Convert.ToDouble(Reader.GetAttribute("top").Replace(GlobalProfile.DecimalSymbolStandard, GlobalProfile.DecimalSymbolSystem))) + yAdd;
                    // better way to locate region above
                    // top = GlobalParams.Grider((int)((double)1.28 * Convert.ToDouble(Reader.GetAttribute("align-y").Replace(GlobalParams.DecimalSymbolStandard, GlobalParams.DecimalSymbolSystem))) - height / 2 + yAdd);

                    // better way to retrieve highlight color from mathcad
                    //  if (Convert.ToBoolean(Reader.GetAttribute("show-highlight")) && bgcolor != null && bgcolor != "" && bgcolor != "inherit")
                    //      CLR2 = SMath.Drawing.Graphics.WebColorToColor(bgcolor);
                    bgcolor = Reader.GetAttribute("background-color");
                    if (bgcolor.Length == 4)
                        bgcolor = "#fff" + bgcolor.Substring(1);
                    highlight = Convert.ToBoolean(Reader.GetAttribute("show-highlight"));
                    if (highlight && bgcolor == "inherit")
                    {
                        CLR2 = SMath.Drawing.Graphics.WebColorToColor(mcadSettings.defaultHighlightColor.ToString());
                    }
                    else if (highlight && (bgcolor != null) && (bgcolor != "") && (bgcolor != "inherit"))
                    {
                        CLR2 = SMath.Drawing.Graphics.WebColorToColor(bgcolor.ToString());
                    }

                    border = Convert.ToBoolean(Reader.GetAttribute("show-border"));

                    // if set tag attribute in .xmcd file to "debug" you can set a breakpoint here and step through
                    debug = Reader.GetAttribute("tag");
                    if (debug == "debug")
                        Console.WriteLine("debug stop");

                    while (Reader.Read())
                    {
                        Reader.MoveToContent();
                        if (Reader.NodeType == XmlNodeType.EndElement && Reader.Name == "region")
                        {
                            regions--;
                            if (regions < 0)
                                return;
                            else
                                break;
                        }
                        if (Reader.NodeType == XmlNodeType.Element && (Reader.Name == "rendering" || Reader.Name == "resultFormat"))
                            Reader.Skip();
                        else if (Reader.Name.ToLower() == "math")
                        {
                            if (Reader.NodeType == XmlNodeType.EndElement)
                                continue;

                            string disableCalc = Reader.GetAttribute("disable-calc");
                            if (string.IsNullOrEmpty(disableCalc))
                                disableCalc = "false";

                            List<Term>
                                array = new List<Term>();
                            Stack<int>
                                parentId = new Stack<int>();
                            List<string>
                                localVars = new List<string>();

                            try
                            {
                                MathRegion v = new MathRegion(context.SessionProfile);
                                v.ResetColors(context.SessionProfile.Drawing.TextColor, Color.FromArgb(CLR2));

                                // Parses XML to prefix math expression.
                                RecurseParse(context, v, array, Reader, parentId);

                                // Converts prefix notation to postfix.
                                Term[] res = PrefixToPostfix(array.ToArray());

                                // Finds all global and local variables to skip trying to convert them into units.
                                if (res[res.Length - 1].Type == TermType.Operator && res[res.Length - 1].Text == Operators.Definition)
                                {
                                    Term[][] parts = SMath.Manager.Expression.Split(res, res.Length - 1);
                                    if (parts.Length == 2)
                                    {
                                        if (parts[0].Length == 1)
                                            globalVars.Add(parts[0][0].Text);
                                        else if (parts[0][parts[0].Length - 1].Type == TermType.Function)
                                        {
                                            for (int i = 0; i < parts[0].Length - 1; i++)
                                                localVars.Add(parts[0][i].Text);
                                        }
                                    }
                                }

                                // Corrects known inconsistencies between Mathcad and SMath Studio expression notations.
                                for (int i = res.Length - 1; i >= 0; i--)
                                {
                                    if (res[i].Type == TermType.Function)
                                    {
                                        if (res[i].Text == "log" && res[i].ArgsCount == 1)
                                        {
                                            res[i].Text = Functions.Lg;
                                        }

                                        if (context.SessionProfile.NamingType != GlobalProfile.namingWorld)
                                        {
                                            TermInfo info;
                                            if (TermInfo.IsPreserved(context.SessionProfile, res[i], out info, true))
                                            {
                                                info.NameGuid = context.SessionProfile.NamingType;
                                                res[i].Text = info.Text;
                                            }
                                        }

                                        if (res[i].Text == "Γ")
                                        {
                                            res[i].Text = Functions.Gamma;
                                        }
                                        else if (res[i].Text == Functions.Nthroot || res[i].Text == Functions.Diff)
                                        {
                                            int glob;
                                            Term[][] temp = Expression.Split(res, i, out glob);
                                            if (temp.Length != 2)
                                                continue;
                                            for (int j = temp.Length - 1; j >= 0; j--)
                                            {
                                                for (int m = 0; m < temp[j].Length; m++)
                                                {
                                                    res[i - (glob--)] = temp[j][m];
                                                }
                                            }
                                        }
                                        else if (res[i].Text == Functions.Mat)
                                        {
                                            int glob;
                                            Term[][] temp = Expression.Split(res, i, out glob);
                                            res[i - 2] = temp[0][0];
                                            res[i - 1] = temp[1][0];
                                            int
                                                rows = Convert.ToInt32(temp[0][0].Text),
                                                cols = Convert.ToInt32(temp[1][0].Text);

                                            for (int j = 0, shift = i - glob; j < temp.Length - 2; j++)
                                            {
                                                int r = j / cols;
                                                int c = j % cols;
                                                int ind = r + c * rows + 2;

                                                for (int m = 0; m < temp[ind].Length; m++)
                                                {
                                                    res[shift++] = temp[ind][m];
                                                }
                                            }
                                        }
                                    }
                                    else if (res[i].Type == TermType.Operand)
                                    {
                                        bool unitize = true;
                                        foreach (string globalVar in globalVars)
                                        {
                                            if (res[i].Text == globalVar)
                                            {
                                                unitize = false;
                                                break;
                                            }
                                        }
                                        if (!unitize)
                                            continue;

                                        foreach (string localVar in localVars)
                                        {
                                            if (res[i].Text == localVar)
                                            {
                                                unitize = false;
                                                break;
                                            }
                                        }

                                        if (!unitize)
                                            continue;

                                        UnitInfo unitDef;
                                        if (UnitsManager.TryGetUnit(context.SessionProfile, Symbols.UnitChar + res[i].Text, out unitDef, true))
                                            res[i].Text = unitDef.Text;
                                    }
                                }

                                v.Evaluable = !Convert.ToBoolean(disableCalc);
                                v.Answer.FractionType = GlobalProfile.FractionsTypeNumeric;
                                v.Size = new Size(width, height);
                                v.Border = border;
                                v.Location = new Point(left, top);
                                controls.Push(v);
                                v.Terms = res;
                            }
                            catch (Exception e)
                            {
                                // add a little extra error text
                                string error = "";
                                error = String.Format("Error while parsing XML math expression: {0} [region-id: {1}] {2}", Reader.Name, regionID, e.Message);
                                errStrings.Add(error);
                                //
                                errorsCount++;
                                Reader.Skip();
                            }
                        }
                        else if (Reader.Name.ToLower() == "text") // Added text region to interpretations
                        {
                            if (Reader.NodeType == XmlNodeType.EndElement)
                                continue;

                            string text = "";
                            // default "Normal" Style from MathCad
                            string textstyle = "Normal";
                            string fontname = "Arial";
                            int fontsize = 10;
                            bool bold = false;
                            bool underline = false;
                            bool italics = false;

                            TextRegion v = new TextRegion(context.SessionProfile);
                            v.ResetColors(context.SessionProfile.Drawing.TextColor, Color.FromArgb(CLR2));

                            while (Reader.Read())
                            {
                                Reader.MoveToContent();
                                if (Reader.NodeType == XmlNodeType.EndElement && Reader.Name == "text")
                                    break;
                                if (Reader.NodeType == XmlNodeType.Element && Reader.Name.ToLower() == "p")
                                {
                                    textstyle = Reader.GetAttribute("style");
                                    foreach (Styles style in TextStyles)
                                    {
                                        if (style.name == textstyle)
                                        {
                                            bold = style.bold;
                                            italics = style.italics;
                                            underline = style.underline;
                                            fontsize = style.fontsize;
                                            fontname = style.fontfamily;
                                        }
                                    }
                                    if (string.IsNullOrEmpty(Reader.Value))
                                    {
                                        if (text != "")
                                            text += "\r";
                                    }
                                    else
                                    {
                                        text += Reader.Value;
                                    }
                                    continue;
                                }
                                if (Reader.NodeType == XmlNodeType.Element && Reader.Name.ToLower() == "b")
                                {
                                    bold = true;
                                }
                                if (Reader.NodeType == XmlNodeType.Element && Reader.Name.ToLower() == "u")
                                {
                                    underline = true;
                                }
                                if (Reader.NodeType == XmlNodeType.Element && Reader.Name.ToLower() == "i")
                                {
                                    italics = true;
                                }
                                if (Reader.NodeType == XmlNodeType.Element && Reader.Name.ToLower() == "f")
                                {
                                    if (Reader.GetAttribute("size") != null)
                                        Int32.TryParse(Reader.GetAttribute("size"), out fontsize);
                                }
                                if (!string.IsNullOrEmpty(Reader.Value))
                                    text += Reader.Value;
                            }
                            v.Size = new Size(width, height);
                            v.Border = border;
                            v.Location = new Point(left, top);
                            v.Bold = bold;
                            v.Italic = italics;
                            v.Underline = underline;
                            v.FontHeight = fontsize;
                            v.FontName = fontname;
                            controls.Push(v);
                            v.OnCommandSend(text);
                        }
                        else if (Reader.Name.ToLower() == "area")
                        {
                            if (Reader.NodeType == XmlNodeType.EndElement)
                                continue;

                            string
                                isCollapsed = Reader.GetAttribute("is-collapsed"),
                                showIcon = Reader.GetAttribute("show-icon");

                            RegionBase v1;
                            if (Worksheet.TryGetRegionByTagName(context.SessionProfile, "area", out v1) && v1 is ISeparatorObject)
                            {
                                v1.ResetColors(context.SessionProfile.Drawing.TextColor, Color.FromArgb(CLR2));

                                top += height / 2 - 17;
                                if (String.IsNullOrEmpty(isCollapsed))
                                    ((ISeparatorObject)v1).Collapse(false);
                                else
                                {
                                    ((ISeparatorObject)v1).Collapse(Convert.ToBoolean(isCollapsed));
                                    if (((ISeparatorObject)v1).Collapsed)
                                        top += GlobalProfile.CanvasGridSize / 2;
                                }
                                if (String.IsNullOrEmpty(showIcon))
                                    ((ISeparatorObject)v1).Top = false;
                                else
                                    ((ISeparatorObject)v1).Top = Convert.ToBoolean(showIcon);
                                v1.Size = new Size(150, 17);
                                v1.Border = border;
                                v1.Location = new Point(left, top);
                                controls.Push(v1);

                                if (!((ISeparatorObject)v1).Top)
                                    continue;

                                int yAddInto = (((ISeparatorObject)v1).Collapsed ? top : 0);
                                OpenXMCD(context, Reader, ref errorsCount, ref yAddInto, controls, binaryItems);

                                RegionBase v2;
                                if (Worksheet.TryGetRegionByTagName(context.SessionProfile, "area", out v2) && v2 is ISeparatorObject)
                                {
                                    v2.ResetColors(context.SessionProfile.Drawing.TextColor, Color.FromArgb(CLR2));
                                    ((ISeparatorObject)v2).Collapse(false);
                                    ((ISeparatorObject)v2).Top = false;
                                    v2.Size = new Size(150, 17);
                                    v2.Border = border;
                                    v2.Location = new Point(left, top + height);
                                    controls.Push(v2);
                                }

                                yAdd += (((ISeparatorObject)v1).Collapsed ? height : 0);
                            }
                        }
                        else
                        {
                            if (Reader.NodeType == XmlNodeType.EndElement)
                                continue;

                            RegionBase region;

                            try
                            {
                                if (Worksheet.TryGetRegionByTagName(context.SessionProfile, Reader.Name.ToLower(), out region))
                                {
                                    if (Reader.Name.ToLower() == "picture")
                                    {
                                        while (Reader.Read())
                                        {
                                            Reader.MoveToContent();
                                            if (Reader.NodeType == XmlNodeType.Element && Reader.Name == "png")
                                            {
                                                string binnary = binaryItems[Reader.GetAttribute("item-idref")];

                                                var image = Base64StringToImage(binnary);
                                                if ((((double)image.Width / (double)width) > 1.05))
                                                {
                                                    // scale image to fit dimensions
                                                    var bmp = SMath.Drawing.Graphics.Specifics.CreateBitmap(width, height);
                                                    using (var g = SMath.Drawing.Graphics.Specifics.GraphicsFromBitmap(bmp))
                                                        g.DrawImage(image, new Rectangle(0, 0, width, height), new RectangleF(0, 0, image.Width, image.Height));

                                                    binnary = ImageToBase64String(bmp, BitmapFormat.Png);
                                                }

                                                string rawXml = String.Empty;
                                                using (var writer = new MemoryStream())
                                                using (var xmlWriter = XmlWriter.Create(writer))
                                                {
                                                    xmlWriter.WriteStartElement("picture");
                                                    xmlWriter.WriteStartElement("raw");
                                                    xmlWriter.WriteAttributeString("format", "png");
                                                    xmlWriter.WriteAttributeString("encoding", "base64");
                                                    xmlWriter.WriteRaw(binnary);
                                                    xmlWriter.WriteEndElement();
                                                    xmlWriter.WriteEndElement();

                                                    xmlWriter.Flush();
                                                    writer.Position = 0;
                                                    rawXml = Encoding.UTF8.GetString(writer.ToArray());
                                                }

                                                var properties = new PropertiesReader();
                                                var storage = new StorageReader(properties, "picture", rawXml);

                                                region.FromXml(storage, new FileParsingContext(context.SessionProfile));
                                            }
                                            else if (Reader.NodeType == XmlNodeType.EndElement && Reader.Name == "picture")
                                                break;
                                        }
                                    }
                                    else
                                    {
                                        var properties = new PropertiesReader(Reader);
                                        var storage = new StorageReader(properties, "picture", Reader.ReadOuterXml());

                                        Reader.MoveToElement();

                                        region.FromXml(storage, new FileParsingContext(context.SessionProfile));
                                    }

                                    region.ResetColors(context.SessionProfile.Drawing.TextColor, Color.FromArgb(CLR2));
                                    region.Border = border;
                                    // tweaked size by 1 pixel
                                    region.Size = new Size(width + 1, height + 1);
                                    region.Location = new Point(left, top);
                                    if (region is RegionTranslatable)
                                        ((RegionTranslatable)region).SetCurrentValue();
                                    controls.Push(region);
                                }
                            }
                            catch
                            {
                                region = null;
                            }

                            if (region == null)
                            {
                                string error = "";
                                error = String.Format("Error parsing Text, Area, or Custom Region: {0} [region-id: {1}].", Reader.Name, regionID);
                                errStrings.Add(error);
                                errorsCount++;
                                Reader.Skip();
                            }
                        }
                    }
                }
            }
        }

        private void AddTermArgument(List<Term> array, int pos)
        {
#pragma warning disable 618
            array[pos].ChildCount++; // To find a way overcome this issue
#pragma warning restore 618
        }

        private bool intoApplyTag;
        private void RecurseParse(FileContext context, MathRegion region, List<Term> array, XmlReader Reader, Stack<int> parentId)
        {
            while (Reader.Read())
            {
                Reader.MoveToContent();

                if (Reader.NodeType == XmlNodeType.Element && Reader.Name == "result")
                {
                    Reader.Skip();
                    return;
                }
                else if (Reader.NodeType == XmlNodeType.Element && (Reader.Name == "ml:symResult" || Reader.Name == "resultFormat"))
                {
                    Reader.Skip();
                    return;
                }
                else if (Reader.NodeType == XmlNodeType.Element && (Reader.Name == "originRef" || Reader.Name == "parentRef" || Reader.Name == "comment" || Reader.Name == "originComment" || Reader.Name == "contentHash"))
                {
                    Reader.Skip();
                }
                else if (Reader.NodeType == XmlNodeType.Element && (Reader.Name == "ml:apply" || Reader.Name == "ml:function"))
                {
                    // Means that next term will be a function
                    intoApplyTag = true;
                    RecurseParse(context, region, array, Reader, parentId);
                }
                else if (Reader.NodeType == XmlNodeType.Element && Reader.Name == "ml:unitOverride")
                {
                    array.Add(new Term(Symbols.EmptyOperand, TermType.Operand, 0));
                    array.Insert(0, new Term(Operators.NumericEqual, TermType.Operator, 2));

                    RecurseParse(context, region, array, Reader, parentId);
                    array.Insert(0, new Term(Operators.UnitOperator, TermType.Operator, 2));
                }
                else if (Reader.NodeType == XmlNodeType.Element && (Reader.Name == "ml:lambda" || Reader.Name == "ml:sequence" || Reader.Name == "ml:eval" || Reader.Name == "ml:symEval" || Reader.Name == "ml:boundVars" || Reader.Name == "ml:provenance"))
                {
                    RecurseParse(context, region, array, Reader, parentId);
                }
                else if (Reader.NodeType == XmlNodeType.EndElement && (Reader.Name == "ml:apply" || Reader.Name == "ml:matrix" || Reader.Name == "ml:define" || Reader.Name == "ml:parens" || Reader.Name == "ml:range" || Reader.Name == "ml:function"))
                {
                    parentId.Pop();

                    if (parentId.Count != 0)
                        AddTermArgument(array, parentId.Peek());

                    return;
                }
                else if (Reader.NodeType == XmlNodeType.EndElement && (Reader.Name == "math" || Reader.Name == "ml:lambda" || Reader.Name == "ml:sequence" || Reader.Name == "ml:boundVars" || Reader.Name == "ml:provenance" || Reader.Name == "ml:unitOverride"))
                {
                    return;
                }
                else if (Reader.NodeType == XmlNodeType.EndElement && Reader.Name == "ml:eval")
                {
                    // Check if Unit tag already inserted an eval operator.
                    region.Optimization = OptimizationType.Numeric;  // default should be Numeric.
                    if (array.Count < 1 || array[0].Type != TermType.Operator || array[0].Text != Operators.UnitOperator)
                    {
                        array.Add(new Term(Symbols.EmptyOperand, TermType.Operand, 0));
                        array.Insert(0, new Term(Operators.NumericEqual, TermType.Operator, 2));
                        region.Optimization = OptimizationType.Numeric;
                    }
                    return;
                }
                else if (Reader.NodeType == XmlNodeType.EndElement && Reader.Name == "ml:symEval")
                {
                    // Check if Unit tag already inserted an eval operator.
                    if (array.Count < 1 || array[0].Type != TermType.Operator || array[0].Text != Operators.UnitOperator)
                    {
                        array.Add(new Term(Symbols.EmptyOperand, TermType.Operand, 0));
                        array.Insert(0, new Term(Operators.NumericEqual, TermType.Operator, 2));
                        region.Optimization = OptimizationType.Symbolic;
                    }
                    return;
                }
                else if (Reader.NodeType == XmlNodeType.Element && Reader.Name == "ml:matrix")
                {
                    array.Add(new Term(Functions.Mat, TermType.Function, 2));
                    parentId.Push(array.Count - 1);
                    array.Add(new Term(Reader.GetAttribute("rows"), TermType.Operand, 0));
                    array.Add(new Term(Reader.GetAttribute("cols"), TermType.Operand, 0));

                    RecurseParse(context, region, array, Reader, parentId);
                }
                else if (Reader.NodeType == XmlNodeType.Element && Reader.Name == "ml:derivative")
                {
                    array.Add(new Term("diff", TermType.Function, 0));
                    parentId.Push(array.Count - 1);
                }
                else if (Reader.NodeType == XmlNodeType.Element && Reader.Name == "ml:range")
                {
                    array.Add(new Term("range", TermType.Function, 0));
                    parentId.Push(array.Count - 1);

                    RecurseParse(context, region, array, Reader, parentId);
                }
                else if (Reader.NodeType == XmlNodeType.Element && Reader.Name == "ml:define")
                {
                    array.Add(new Term(Operators.Definition, TermType.Operator, 0));
                    parentId.Push(array.Count - 1);

                    RecurseParse(context, region, array, Reader, parentId);
                }
                else if (Reader.NodeType == XmlNodeType.Element && Reader.Name == "ml:parens")
                {
                    array.Add(new Term(Brackets.LeftVisible, TermType.Bracket, 0));
                    parentId.Push(array.Count - 1);

                    RecurseParse(context, region, array, Reader, parentId);
                }
                else if (Reader.NodeType == XmlNodeType.Element && Reader.Name == "ml:real")
                {
                    Reader.Read();
                    Reader.MoveToContent();

                    if (Reader.Value.StartsWith(Operators.Subtraction))
                    {
                        array.Add(new Term(Operators.Subtraction, TermType.Operator, 1));
                    }

                    array.Add(new Term(Reader.Value.TrimStart('-'), TermType.Operand, 0));

                    if (parentId.Count != 0)
                        AddTermArgument(array, parentId.Peek());

                    Reader.Read();
                    Reader.MoveToContent();
                }
                else if (Reader.NodeType == XmlNodeType.Element && Reader.Name == "ml:imag")
                {
                    Reader.Read();
                    Reader.MoveToContent();

                    string Value = Reader.Value;
                    if (Value.StartsWith(Operators.Subtraction))
                    {
                        array.Add(new Term(Operators.Subtraction, TermType.Operator, 1));
                    }

                    Value = Reader.Value.TrimStart('-');

                    if (Value == "1")
                        array.Add(new Term(Symbols.ImaginaryUnit, TermType.Operand, 0));
                    else
                    {
                        array.Add(new Term(Operators.Multiplication, TermType.Operator, 2));
                        array.Add(new Term(Value.TrimStart('-'), TermType.Operand, 0));
                        array.Add(new Term(Symbols.ImaginaryUnit, TermType.Operand, 0));
                    }

                    if (parentId.Count != 0)
                        AddTermArgument(array, parentId.Peek());

                    Reader.Read();
                    Reader.MoveToContent();
                }
                else if (Reader.NodeType == XmlNodeType.Element && Reader.Name == "ml:placeholder")
                {
                    array.Add(new Term(Symbols.EmptyOperand, TermType.Operand, 0));

                    if (parentId.Count != 0)
                        AddTermArgument(array, parentId.Peek());
                }
                else
                {
                    if (Reader.NodeType == XmlNodeType.Element && Reader.Name == "ml:id")
                    {
                        // fixed so that the subscript is interpreted correctly!!!!
                        int i = 0;
                        bool percentFlag = false;
                        int operandLength = 0;
                        char[] operand_byteArray = null;
                        string operand = "";
                        string subscript = "";

                        // Get the subscript if it exists
                        subscript = Reader.GetAttribute("subscript");

                        Reader.Read();

                        operandLength = Reader.Value.Length;
                        operand_byteArray = new char[operandLength + 1];
                        operand_byteArray = Reader.Value.ToCharArray();

                        for (i = 0; i < operandLength; i++)
                        {
                            // can replace problem characters in variable names here
                            if (operand_byteArray[i] == '’') // problems with this char
                                operand_byteArray[i] = '`';  // replaced it with the grave char
                            if (operand_byteArray[i] == '%') // problems with this char
                                percentFlag = true;
                        }
                        string str = new string(operand_byteArray).Substring(0, i);

                        // MathCAD allows i as a variable
                        // SMath does not allow imaginary #'s and i as a variable at the same time.
                        // So, replace variable "i" with "i_"
                        if ((operandLength == 1) && (operand_byteArray[0] == 'i'))
                            str = str + "_";
                        // replace % with Percent"
                        if (percentFlag)
                            str = str.Replace("%", "Percent");

                        if (subscript != null)
                            operand = str + GlobalProfile.DecimalSymbolStandard + subscript;
                        else
                            operand = str;

                        if (!intoApplyTag)
                            array.Add(new Term(operand, TermType.Operand, 0));
                        else
                            array.Add(new Term(operand, TermType.Function, 0));

                        Reader.Read();

                        if (!intoApplyTag)
                        {
                            if (parentId.Count != 0)
                                AddTermArgument(array, parentId.Peek());

                            continue;
                        }
                    }
                    else if (Reader.NodeType == XmlNodeType.Element && Reader.Name == "ml:str")
                    {
                        Reader.Read();
                        array.Add(new Term("\"" + Reader.Value + "\"", TermType.Operand, 0));
                        Reader.Read();

                        if (parentId.Count != 0)
                            AddTermArgument(array, parentId.Peek());

                        continue;
                    }
                    else if (Reader.NodeType == XmlNodeType.Element && Reader.Name == "ml:unknownOp")
                        array.Add(new Term(Operators.EmptyOperator, TermType.Operator, 0));
                    else if (Reader.NodeType == XmlNodeType.Element && Reader.Name == "ml:equal")
                        array.Add(new Term(Operators.BooleanEqual, TermType.Operator, 0));
                    else if (Reader.NodeType == XmlNodeType.Element && Reader.Name == "ml:lessThan")
                        array.Add(new Term(Operators.BooleanLess, TermType.Operator, 0));
                    else if (Reader.NodeType == XmlNodeType.Element && Reader.Name == "ml:greaterThan")
                        array.Add(new Term(Operators.BooleanMore, TermType.Operator, 0));
                    else if (Reader.NodeType == XmlNodeType.Element && Reader.Name == "ml:lessOrEqual")
                        array.Add(new Term(Operators.BooleanLessOrEqual, TermType.Operator, 0));
                    else if (Reader.NodeType == XmlNodeType.Element && Reader.Name == "ml:greaterOrEqual")
                        array.Add(new Term(Operators.BooleanMoreOrEqual, TermType.Operator, 0));
                    else if (Reader.NodeType == XmlNodeType.Element && Reader.Name == "ml:notEqual")
                        array.Add(new Term(Operators.BooleanNotEqual, TermType.Operator, 0));
                    else if (Reader.NodeType == XmlNodeType.Element && Reader.Name == "ml:not")
                        array.Add(new Term(Operators.BooleanNot, TermType.Operator, 0));
                    else if (Reader.NodeType == XmlNodeType.Element && Reader.Name == "ml:and")
                        array.Add(new Term(Operators.BooleanAnd, TermType.Operator, 0));
                    else if (Reader.NodeType == XmlNodeType.Element && Reader.Name == "ml:or")
                        array.Add(new Term(Operators.BooleanOr, TermType.Operator, 0));
                    else if (Reader.NodeType == XmlNodeType.Element && Reader.Name == "ml:xor")
                        array.Add(new Term(Operators.BooleanXor, TermType.Operator, 0));
                    else if (Reader.NodeType == XmlNodeType.Element && Reader.Name == "ml:factorial")
                        array.Add(new Term(Operators.Factorial, TermType.Operator, 0));
                    else if (Reader.NodeType == XmlNodeType.Element && Reader.Name == "ml:plus")
                        array.Add(new Term(Operators.Composition, TermType.Operator, 0));
                    else if (Reader.NodeType == XmlNodeType.Element && (Reader.Name == "ml:minus" || Reader.Name == "ml:neg"))
                        array.Add(new Term(Operators.Subtraction, TermType.Operator, 0));
                    else if (Reader.NodeType == XmlNodeType.Element && Reader.Name == "ml:mult")
                        array.Add(new Term(Operators.Multiplication, TermType.Operator, 0));
                    else if (Reader.NodeType == XmlNodeType.Element && Reader.Name == "ml:div")
                        array.Add(new Term(Operators.Division, TermType.Operator, 0));
                    else if (Reader.NodeType == XmlNodeType.Element && Reader.Name == "ml:pow")
                        array.Add(new Term(Operators.Exponentiation, TermType.Operator, 0));
                    else if (Reader.NodeType == XmlNodeType.Element && Reader.Name == "ml:crossProduct")
                        array.Add(new Term(Operators.VectorMultiplication, TermType.Operator, 0));
                    else if (Reader.NodeType == XmlNodeType.Element && Reader.Name == "ml:absval")
                        array.Add(new Term(Functions.Abs, TermType.Function, 0));
                    else if (Reader.NodeType == XmlNodeType.Element && Reader.Name == "ml:sqrt")
                        array.Add(new Term(Functions.Sqrt, TermType.Function, 0));
                    else if (Reader.NodeType == XmlNodeType.Element && Reader.Name == "ml:nthRoot")
                        array.Add(new Term(Functions.Nthroot, TermType.Function, 0));
                    else if (Reader.NodeType == XmlNodeType.Element && Reader.Name == "ml:transpose")
                        array.Add(new Term(Functions.Transpose, TermType.Function, 0));
                    else if (Reader.NodeType == XmlNodeType.Element && Reader.Name == "ml:determinant")
                        array.Add(new Term(Functions.Det, TermType.Function, 0));
                    else
                    {
                        intoApplyTag = false;
                        throw new NotSupportedException();
                    }

                    parentId.Push(array.Count - 1);
                }
                intoApplyTag = false;
            }
        }

        private XmlAttribute CreateXMLAttribute(string name, string value, XmlDocument doc, XmlNode node)
        {
            XmlAttribute attribute = doc.CreateAttribute(name);
            attribute.Value = value;
            node.Attributes.Append(attribute);

            return attribute;
        }

        #endregion

        #region XMCD file save methods

        private readonly string
            uri1 = "http://schemas.mathsoft.com/worksheet30",
            uri2 = "http://schemas.mathsoft.com/math30";

        public void SaveToXMCD(FileContext context, XmlTextWriter writer, ref int errorsCount, RegionsEnumerator enumerator)
        {
            writer.Formatting = Formatting.Indented;
            writer.WriteStartDocument(true);
            // for xml binaryContent
            Dictionary<string, string> binaryItems = new Dictionary<string, string>();

            XmlDocument doc = new XmlDocument();
            string settings =
                "<worksheet version=\"3.0.3\" xmlns=\"" + uri1 + "\" xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\" xmlns:ws=\"" + uri1 + "\" xmlns:ml=\"" + uri2 + "\" xmlns:u=\"http://schemas.mathsoft.com/units10\" xmlns:p=\"http://schemas.mathsoft.com/provenance10\">" +
                "<settings>" +
                "<presentation>" +
                "<textRendering>" +
                "<textStyles>" +
                "<textStyle name=\"Normal\">" +
                "<blockAttr margin-left=\"0\" margin-right=\"0\" text-indent=\"inherit\" text-align=\"left\" list-style-type=\"inherit\" tabs=\"inherit\"/>" +
                "<inlineAttr font-family=\"Arial\" font-charset=\"0\" font-size=\"10\" font-weight=\"normal\" font-style=\"normal\" underline=\"false\" line-through=\"false\" vertical-align=\"baseline\"/>" +
                "</textStyle>" +
                "</textStyles>" +
                "</textRendering>" +
                "<mathRendering equation-color=\"#000\">" +
                "<operators multiplication=\"narrow-dot\" derivative=\"derivative\" literal-subscript=\"large\" definition=\"colon-equal\" global-definition=\"triple-equal\" local-definition=\"left-arrow\" equality=\"bold-equal\" symbolic-evaluation=\"right-arrow\"/>" +
                "<mathStyles>" +
                "<mathStyle name=\"Variables\" font-family=\"Times New Roman\" font-charset=\"0\" font-size=\"10\" font-weight=\"normal\" font-style=\"normal\" underline=\"false\"/>" +
                "<mathStyle name=\"Constants\" font-family=\"Times New Roman\" font-charset=\"0\" font-size=\"10\" font-weight=\"normal\" font-style=\"normal\" underline=\"false\"/>" +
                "<mathStyle name=\"User 1\" font-family=\"Arial\" font-charset=\"0\" font-size=\"10\" font-weight=\"normal\" font-style=\"normal\" underline=\"false\"/>" +
                "<mathStyle name=\"User 2\" font-family=\"Courier New\" font-charset=\"0\" font-size=\"10\" font-weight=\"normal\" font-style=\"normal\" underline=\"false\"/>" +
                "<mathStyle name=\"User 3\" font-family=\"Arial\" font-charset=\"0\" font-size=\"10\" font-weight=\"bold\" font-style=\"normal\" underline=\"false\"/>" +
                "<mathStyle name=\"User 4\" font-family=\"Times New Roman\" font-charset=\"0\" font-size=\"10\" font-weight=\"normal\" font-style=\"italic\" underline=\"false\"/>" +
                "<mathStyle name=\"User 5\" font-family=\"Times New Roman\" font-charset=\"0\" font-size=\"10\" font-weight=\"normal\" font-style=\"normal\" underline=\"false\"/>" +
                "<mathStyle name=\"User 6\" font-family=\"Arial\" font-charset=\"0\" font-size=\"10\" font-weight=\"normal\" font-style=\"normal\" underline=\"false\"/>" +
                "<mathStyle name=\"User 7\" font-family=\"Times New Roman\" font-charset=\"0\" font-size=\"10\" font-weight=\"normal\" font-style=\"normal\" underline=\"false\"/>" +
                "<mathStyle name=\"Math Text Font\" font-family=\"Times New Roman\" font-charset=\"0\" font-size=\"14\" font-weight=\"normal\" font-style=\"normal\" underline=\"false\"/>" +
                "</mathStyles>" +
                "<dimensionNames mass=\"mass\" length=\"length\" time=\"time\" current=\"current\" thermodynamic-temperature=\"temperature\" luminous-intensity=\"luminosity\" amount-of-substance=\"substance\" display=\"false\"/>" +
                "<symbolics derivation-steps-style=\"vertical-insert\" show-comments=\"false\" evaluate-in-place=\"false\"/>" +
                "<results numeric-only=\"true\">" +
                "<general precision=\"3\" show-trailing-zeros=\"false\" radix=\"dec\" complex-threshold=\"10\" zero-threshold=\"15\" imaginary-value=\"i\" exponential-threshold=\"3\"/>" +
                "<matrix display-style=\"auto\" expand-nested-arrays=\"false\"/>" +
                "<unit format-units=\"true\" simplify-units=\"true\" fractional-unit-exponent=\"false\"/>" +
                "</results>" +
                "</mathRendering>" +
                //"<pageModel show-page-frame=\"false\" show-header-frame=\"false\" show-footer-frame=\"false\" header-footer-start-page=\"1\" paper-code=\"9\" orientation=\"portrait\" print-single-page-width=\"false\" page-width=\"595.5\" page-height=\"841.5\">" +
                //"<margins left=\"86.4\" right=\"86.4\" top=\"86.4\" bottom=\"86.4\"/>" +
                //"<header use-full-page-width=\"false\"/>" +
                //"<footer use-full-page-width=\"false\"/>" +
                // changed how header is saved
                "<pageModel show-page-frame=\"" + globalpageModel.show_page_frame + "\" show-header-frame=\"" + globalpageModel.show_header_frame + "\" show-footer-frame=\"" + globalpageModel.show_footer_frame +
                    "\" header-footer-start-page=\"1\" paper-code=\"" + globalpageModel.paper_code + "\" orientation=\"" + globalpageModel.orientation + "\" print-single-page-width=\"" + globalpageModel.print_single_page_width +
                "\" page-width=\"" + globalpageModel.width.ToString() + "\" page-height=\"" + globalpageModel.height.ToString() + "\">" +
                "<margins left=\"" + globalpageModel.margins.left.ToString() + "\" right=\"" + globalpageModel.margins.right.ToString() + "\" top=\"" + globalpageModel.margins.top.ToString() + "\" bottom=\"" + globalpageModel.margins.bottom.ToString() + "\"/>" +
                "<header use-full-page-width=\"true\">" +
                "<left>" + globalpageModel.header.left + "</left>" +
                "<center>" + globalpageModel.header.center + "</center>" +
                "<right>" + globalpageModel.header.right + "</right>" +
                "</header>" +
                "<footer use-full-page-width=\"true\">" +
                "<left>" + globalpageModel.footer.left + "</left>" +
                "<center>" + globalpageModel.footer.center + "</center>" +
                "<right>" + globalpageModel.footer.right + "</right>" +
                "</footer>" +
                //
                "</pageModel>" +
                "<colorModel background-color=\"#fff\" default-highlight-color=\"#ffff80\"/>" +
                "<language math=\"en\" UI=\"en\"/>" +
                "</presentation>" +
                "<calculation>" +
                "<builtInVariables array-origin=\"0\" convergence-tolerance=\"0.001\" constraint-tolerance=\"0.001\" random-seed=\"1\" prn-precision=\"4\" prn-col-width=\"8\"/>" +
                "<calculationBehavior automatic-recalculation=\"true\" matrix-strict-singularity-check=\"true\" optimize-expressions=\"false\" exact-boolean=\"true\" strings-use-origin=\"false\" zero-over-zero=\"0\">" +
                "<compatibility multiple-assignment=\"MC12\" local-assignment=\"MC12\"/>" +
                "</calculationBehavior>" +
                "<units>" +
                "<currentUnitSystem name=\"si\" customized=\"false\"/>" +
                "</units>" +
                "</calculation>" +
                "<editor view-annotations=\"false\" view-regions=\"false\">" +
                "<ruler is-visible=\"false\" ruler-unit=\"cm\"/>" +
                "<grid granularity-x=\"6\" granularity-y=\"6\"/>" +
                "</editor>" +
                "<fileFormat image-type=\"none\" image-quality=\"75\" save-numeric-results=\"true\" exclude-large-results=\"false\" save-text-images=\"false\" screen-dpi=\"96\"/>" +
                "<miscellaneous>" +
                "<handbook handbook-region-tag-ub=\"1\" can-delete-original-handbook-regions=\"true\" can-delete-user-regions=\"true\" can-print=\"true\" can-copy=\"true\" can-save=\"true\" file-permission-mask=\"4294967295\"/>" +
                "</miscellaneous>" +
                "</settings>" +
                "<regions>" +
                "</regions>" +
                "</worksheet>";
            doc.LoadXml(settings);

            int id = 0;
            int binary_id = 0;
            while (enumerator.MoveNext())
            {
                id++;
                if (enumerator.Current is ISeparatorObject)
                    id += 2;

                bool highlighted = false;
                if (enumerator.Current.BackColor.ToArgb() != SystemSpecificColors.Window.ToArgb())
                    highlighted = true;

                XmlElement regionNode = doc.CreateElement("region", uri1);
                CreateXMLAttribute("region-id", id.ToString(), doc, regionNode);
                // used 1.395 instead of 1.28 and then change to using a variable instead to make it easier to change later.
                CreateXMLAttribute("left", (Math.Round(4 * (((double)enumerator.Current.Location.X + (double)GlobalProfile.CanvasGridSize / 2.0) / mcadSettings.scaleFactor), MidpointRounding.ToEven) / 4).ToString("0.##", CultureInfo.InvariantCulture), doc, regionNode);
                // CreateXMLAttribute("left", ((int)(((double)enumerator.Current.Location.X + GlobalParams.CanvasGridSize / 2) / 1.28)).ToString(), doc, regionNode);
                // fixed coordinates
                CreateXMLAttribute("top", (Math.Round(4 * (((double)enumerator.Current.Location.Y) / mcadSettings.scaleFactor), MidpointRounding.ToEven) / 4).ToString("0.##", CultureInfo.InvariantCulture), doc, regionNode);
                //CreateXMLAttribute("top", ((int)((double)enumerator.Current.Location.Y / 1.28) + enumerator.Current.Size.Height / 2).ToString(), doc, regionNode);
                CreateXMLAttribute("width", (Math.Round(4 * ((double)enumerator.Current.Size.Width / mcadSettings.scaleFactor), MidpointRounding.ToEven) / 4).ToString("0.##", CultureInfo.InvariantCulture), doc, regionNode);
                CreateXMLAttribute("height", (Math.Round(4 * ((double)enumerator.Current.Size.Height / mcadSettings.scaleFactor), MidpointRounding.ToEven) / 4).ToString("0.##", CultureInfo.InvariantCulture), doc, regionNode);
                CreateXMLAttribute("align-x", (Math.Round(4 * ((double)enumerator.Current.Location.X / mcadSettings.scaleFactor), MidpointRounding.ToEven) / 4).ToString("0.##", CultureInfo.InvariantCulture), doc, regionNode);
                //  CreateXMLAttribute("align-x", ((int)((double)enumerator.Current.Location.X / 1.28)).ToString(), doc, regionNode);
                // fixed coordinates
                CreateXMLAttribute("align-y", (Math.Round(4 * (((double)enumerator.Current.Location.Y / mcadSettings.scaleFactor) + ((double)enumerator.Current.Size.Height + 5) / mcadSettings.scaleFactor / 2), MidpointRounding.ToEven) / 4).ToString("0.##", CultureInfo.InvariantCulture), doc, regionNode);
                // CreateXMLAttribute("align-y", ((int)((double)enumerator.Current.Location.Y / 1.28) + enumerator.Current.Size.Height / 2).ToString(), doc, regionNode);
                CreateXMLAttribute("show-border", enumerator.Current.Border.ToString().ToLower(), doc, regionNode);
                CreateXMLAttribute("show-highlight", highlighted.ToString().ToLower(), doc, regionNode);
                CreateXMLAttribute("is-protected", "true", doc, regionNode);
                CreateXMLAttribute("z-order", "0", doc, regionNode);
                CreateXMLAttribute("background-color", highlighted ? SMath.Drawing.Graphics.ColorToWebColor(enumerator.Current.BackColor) : "inherit", doc, regionNode);
                CreateXMLAttribute("tag", "", doc, regionNode);

                if (enumerator.Current is MathRegion)
                {
                    try
                    {
                        XmlElement mathNode = doc.CreateElement("math", uri1);
                        CreateXMLAttribute("optimize", "false", doc, mathNode);
                        CreateXMLAttribute("disable-calc", (!((MathRegion)enumerator.Current).Evaluable).ToString().ToLower(), doc, mathNode);

                        Term[]
                            src = ((MathRegion)enumerator.Current).Terms,
                            res;

                        if (src[src.Length - 1] == new Term(Operators.UnitOperator, TermType.Operator, 2))
                        {
                            Term[][] args = SMath.Manager.Expression.Split(src, src.Length - 1);
                            src = args[0];
                        }

                        res = new Term[src.Length];

                        // Копируем массив элементов, что бы не повлиять на исходные объекты
                        for (int k = res.Length - 1; k >= 0; k--)
                            res[k] = new Term(src[k]);

                        // Препроцессинг - подготовка массива элементов выражения для экспорта
                        for (int k = res.Length - 1; k >= 0; k--)
                        {
                            if (res[k].Type == TermType.Function)
                            {
                                if (context.SessionProfile.NamingType != GlobalProfile.namingWorld)
                                {
                                    if (res[k].Text == Functions.Lg)
                                        res[k].Text = Functions.Log;
                                    else
                                    {
                                        TermInfo info;
                                        if (TermInfo.IsPreserved(context.SessionProfile, res[k], out info, true))
                                        {
                                            info.NameGuid = GlobalProfile.namingWorld;
                                            res[k].Text = info.Text;
                                            info.NameGuid = context.SessionProfile.NamingType;
                                        }
                                    }
                                }

                                if (res[k].Text == Functions.Gamma)
                                {
                                    res[k].Text = "Γ";
                                }
                                else if (res[k].Text == Functions.Nthroot)
                                {
                                    int glob;
                                    Term[][] temp = Expression.Split(res, k, out glob);
                                    if (temp.Length != 2)
                                        continue;
                                    for (int j = temp.Length - 1; j >= 0; j--)
                                    {
                                        for (int m = 0; m < temp[j].Length; m++)
                                        {
                                            res[k - (glob--)] = temp[j][m];
                                        }
                                    }
                                }
                                else if (res[k].Text == Functions.Mat)
                                {
                                    int glob;
                                    Term[][] temp = Expression.Split(res, k, out glob);
                                    int
                                        rows = Convert.ToInt32(temp[temp.Length - 2][0].Text),
                                        cols = Convert.ToInt32(temp[temp.Length - 1][0].Text);
                                    for (int j = 0, invert = 1, max = temp.Length - 2; j < max;)
                                    {
                                        for (int m = 0; m < temp[j].Length; m++)
                                        {
                                            res[k - (glob--)] = temp[j][m];
                                        }
                                        j += cols;
                                        if (j >= max)
                                            j = invert++;
                                        if (invert > cols)
                                            break;
                                    }
                                }
                            }
                        }

                        Term[] ei = PostfixToPrefix(res);

                        this.currentPos = -1;
                        RecurseFill(context, (MathRegion)enumerator.Current, ei, 1, mathNode, doc);

                        regionNode.AppendChild(mathNode);
                    }
                    catch (Exception e)
                    {
                        // add additional error string
                        string error = "";
                        error = e.ToString();
                        errStrings.Add(error);
                        //
                        errorsCount++;
                        continue;
                    }
                }
                else if (enumerator.Current is TextRegion) // added handling of text regions
                {
                    XmlElement textNode = doc.CreateElement("text", uri1);
                    CreateXMLAttribute("use-page-width", "false", doc, textNode);
                    CreateXMLAttribute("push-down", "false", doc, textNode);
                    CreateXMLAttribute("lock-width", "false", doc, textNode);

                    XmlElement paragraphNode = doc.CreateElement("p", uri1);
                    CreateXMLAttribute("style", "Normal", doc, paragraphNode);
                    CreateXMLAttribute("margin-left", "inherit", doc, paragraphNode);
                    CreateXMLAttribute("margin-right", "inherit", doc, paragraphNode);
                    CreateXMLAttribute("text-indent", "inherit", doc, paragraphNode);
                    CreateXMLAttribute("text-align", "inherit", doc, paragraphNode);
                    CreateXMLAttribute("list-style-type", "inherit", doc, paragraphNode);
                    CreateXMLAttribute("tabs", "inherit", doc, paragraphNode);

                    // put back text styles
                    XmlElement boldNode = null;
                    XmlElement italicNode = null;
                    XmlElement underlineNode = null;
                    if (((TextRegion)enumerator.Current).Bold)
                        boldNode = doc.CreateElement("b", uri1);
                    if (((TextRegion)enumerator.Current).Italic)
                        italicNode = doc.CreateElement("i", uri1);
                    if (((TextRegion)enumerator.Current).Underline)
                        underlineNode = doc.CreateElement("u", uri1);

                    XmlElement fontNode = doc.CreateElement("f", uri1);
                    CreateXMLAttribute("size", ((TextRegion)enumerator.Current).FontHeight.ToString(), doc, fontNode);
                    fontNode.InnerText = ((TextRegion)enumerator.Current).Text;

                    if (underlineNode != null)
                    {
                        underlineNode.AppendChild(fontNode);
                        if (italicNode != null)
                        {
                            italicNode.AppendChild(underlineNode);
                            if (boldNode != null)
                            {
                                boldNode.AppendChild(italicNode);
                                paragraphNode.AppendChild(boldNode);
                            }
                            else
                            {
                                paragraphNode.AppendChild(italicNode);
                            }
                        }
                        else if (boldNode != null)
                        {
                            boldNode.AppendChild(underlineNode);
                            paragraphNode.AppendChild(boldNode);
                        }
                        else
                        {
                            paragraphNode.AppendChild(underlineNode);
                        }
                    }
                    else if (italicNode != null)
                    {
                        italicNode.AppendChild(fontNode);
                        if (boldNode != null)
                        {
                            boldNode.AppendChild(italicNode);
                            paragraphNode.AppendChild(boldNode);
                        }
                        else
                        {
                            paragraphNode.AppendChild(italicNode);
                        }
                    }
                    else if (boldNode != null)
                    {
                        boldNode.AppendChild(fontNode);
                        paragraphNode.AppendChild(boldNode);
                    }
                    else
                    {
                        paragraphNode.AppendChild(fontNode);
                    }

                    textNode.AppendChild(paragraphNode);
                    regionNode.AppendChild(textNode);
                }
                else if (enumerator.Current is ISeparatorObject)
                {
                    XmlElement areaNode = doc.CreateElement("area", uri1);
                    CreateXMLAttribute("is-collapsed", "true", doc, areaNode);
                    CreateXMLAttribute("name", "", doc, areaNode);
                    CreateXMLAttribute("show-name", "false", doc, areaNode);
                    CreateXMLAttribute("show-border", "true", doc, areaNode);
                    CreateXMLAttribute("show-icon", "false", doc, areaNode);
                    CreateXMLAttribute("show-timestamp", "true", doc, areaNode);
                    CreateXMLAttribute("allow-expand", "false", doc, areaNode);
                    CreateXMLAttribute("is-locked", "false", doc, areaNode);
                    CreateXMLAttribute("timestamp", "", doc, areaNode);
                    CreateXMLAttribute("top-lock-id", (id - 2).ToString(), doc, areaNode);
                    CreateXMLAttribute("bottom-lock-id", (id - 1).ToString(), doc, areaNode);

                    regionNode.AppendChild(areaNode);
                }
                else if (enumerator.Current is IRegionWithEditableText)
                {
                    // my way to do the TextRegion.
                    XmlElement textNode = doc.CreateElement("text", uri1);
                    CreateXMLAttribute("use-page-width", "false", doc, textNode);
                    CreateXMLAttribute("push-down", "false", doc, textNode);
                    CreateXMLAttribute("lock-width", "false", doc, textNode);

                    XmlElement paragraphNode = doc.CreateElement("p", uri1);
                    CreateXMLAttribute("style", "Normal", doc, paragraphNode);
                    CreateXMLAttribute("margin-left", "inherit", doc, paragraphNode);
                    CreateXMLAttribute("margin-right", "inherit", doc, paragraphNode);
                    CreateXMLAttribute("text-indent", "inherit", doc, paragraphNode);
                    CreateXMLAttribute("text-align", "inherit", doc, paragraphNode);
                    CreateXMLAttribute("list-style-type", "inherit", doc, paragraphNode);
                    CreateXMLAttribute("tabs", "inherit", doc, paragraphNode);

                    // put back text styles
                    XmlElement boldNode = null;
                    XmlElement italicNode = null;
                    XmlElement underlineNode = null;

                    if (enumerator.Current is IRegionFormatable)
                    {
                        if (((IRegionFormatable)enumerator.Current).Bold)
                            boldNode = doc.CreateElement("b", uri1);
                        if (((IRegionFormatable)enumerator.Current).Italic)
                            italicNode = doc.CreateElement("i", uri1);
                        if (((IRegionFormatable)enumerator.Current).Underline)
                            underlineNode = doc.CreateElement("u", uri1);
                    }

                    XmlElement fontNode = doc.CreateElement("f", uri1);
                    CreateXMLAttribute("size", enumerator.Current.FontHeight.ToString(), doc, fontNode);
                    fontNode.InnerText = ((IRegionWithEditableText)enumerator.Current).ToString();

                    if (underlineNode != null)
                    {
                        underlineNode.AppendChild(fontNode);
                        if (italicNode != null)
                        {
                            italicNode.AppendChild(underlineNode);
                            if (boldNode != null)
                            {
                                boldNode.AppendChild(italicNode);
                                paragraphNode.AppendChild(boldNode);
                            }
                            else
                            {
                                paragraphNode.AppendChild(italicNode);
                            }
                        }
                        else if (boldNode != null)
                        {
                            boldNode.AppendChild(underlineNode);
                            paragraphNode.AppendChild(boldNode);
                        }
                        else
                        {
                            paragraphNode.AppendChild(underlineNode);
                        }
                    }
                    else if (italicNode != null)
                    {
                        italicNode.AppendChild(fontNode);
                        if (boldNode != null)
                        {
                            boldNode.AppendChild(italicNode);
                            paragraphNode.AppendChild(boldNode);
                        }
                        else
                        {
                            paragraphNode.AppendChild(italicNode);
                        }
                    }
                    else if (boldNode != null)
                    {
                        boldNode.AppendChild(fontNode);
                        paragraphNode.AppendChild(boldNode);
                    }
                    else
                    {
                        paragraphNode.AppendChild(fontNode);
                    }

                    textNode.AppendChild(paragraphNode);
                    regionNode.AppendChild(textNode);
                }
                else
                {
                    // try custom region plug-ins
                    if (enumerator.Current is PictureRegion)
                    {
                        binary_id++;
                        using (var bin_writer = new MemoryStream())
                        {
                            string Format;

                            var xmlWriter = XmlWriter.Create(bin_writer);
                            xmlWriter.WriteStartElement("item");
                            xmlWriter.WriteAttributeString("item-id", binary_id.ToString());

                            var props = new PropertiesWriter(xmlWriter);
                            var storage = new StorageWriter(props, xmlWriter);
                            enumerator.Current.ToXml(storage, new FileParsingContext(context.SessionProfile));

                            // create a reader so that the xml of the binary data can be read.
                            bin_writer.Position = 0;

                            XmlReader xmlReader = XmlReader.Create(bin_writer);
                            xmlReader.MoveToContent();

                            if (xmlReader.Read() && xmlReader.NodeType == XmlNodeType.Element && xmlReader.Name == "raw")
                            {
                                Format = xmlReader.GetAttribute("format");
                                XmlElement pictureNode = doc.CreateElement("picture", uri1);
                                XmlElement pictureFormat = doc.CreateElement(Format, uri1);
                                CreateXMLAttribute("item-idref", binary_id.ToString(), doc, pictureFormat);
                                CreateXMLAttribute("display-width", (Math.Round(4 * (((double)enumerator.Current.Size.Width) / mcadSettings.scaleFactor), MidpointRounding.ToEven) / 4 - 0.5).ToString("0.##", CultureInfo.InvariantCulture), doc, pictureFormat);
                                CreateXMLAttribute("display-height", (Math.Round(4 * (((double)enumerator.Current.Size.Height) / mcadSettings.scaleFactor), MidpointRounding.ToEven) / 4 - 0.5).ToString("0.##", CultureInfo.InvariantCulture), doc, pictureFormat);
                                pictureNode.AppendChild(pictureFormat);
                                regionNode.AppendChild(pictureNode);
                                xmlReader.Read();
                                binaryItems.Add(binary_id.ToString(), xmlReader.Value);
                            }
                        }
                    }
                    // WriterRegion >= 0.7
                    // An interface may be used: public interface IExportToXMCD { void ToXMCD(XmlDocument doc, XmlElement regionNode); }
                    else if (enumerator.Current.GetType().ToString().Equals("WriterRegion.WriterRegion", StringComparison.InvariantCulture))
                    {
                        Type t = enumerator.Current.GetType();

                        var methodInfo = t.GetMethod("ToXMCD", new[] { typeof(XmlDocument), typeof(XmlElement) });

                        if (methodInfo != null)
                        {
                            object[] parametersArray = { doc, regionNode };
                            var xml = methodInfo.Invoke(enumerator.Current, parametersArray);
                        }
                        else
                        {
                            string error = "";
                            error = enumerator.Current.ToString() + " is an invalid Region";
                            errStrings.Add(error);
                            errorsCount++;
                            continue;
                        }
                    }
                    else
                    {
                        string error = "";
                        error = enumerator.Current.ToString() + " is an invalid Region";
                        errStrings.Add(error);
                        errorsCount++;
                        continue;
                    }
                }
                doc.SelectSingleNode("/*/*[last()]").AppendChild(regionNode);
            }
            //
            // Add binary objects to the end.
            //
            if (binaryItems.Count > 0)
            {
                XmlElement binaryNode = doc.CreateElement("binaryContent", uri1);
                foreach (KeyValuePair<string, string> bin_item in binaryItems)
                {
                    XmlElement itemNode = doc.CreateElement("item", uri1);
                    CreateXMLAttribute("item-id", bin_item.Key, doc, itemNode);
                    itemNode.InnerText = bin_item.Value;
                    binaryNode.AppendChild(itemNode);
                    doc.SelectSingleNode("/*[last()]").AppendChild(binaryNode);
                }
            }
            doc.Save(writer);
        }

        private int
            currentPos;
        private void RecurseFill(FileContext context, MathRegion region, Term[] ei, int childrenCount, XmlElement node, XmlDocument doc)
        {
            while (true)
            {
                currentPos++;
                XmlElement elemNode = null;

                if (ei[currentPos].Type == TermType.Operand)
                {
                    if (ei[currentPos].Text == Symbols.EmptyOperand)
                    {
                        elemNode = doc.CreateElement("ml:placeholder", uri2);
                    }
                    else if (ei[currentPos].Text == Symbols.ImaginaryUnit)
                    {
                        elemNode = doc.CreateElement("ml:imag", uri2);
                        CreateXMLAttribute("symbol", "i", doc, elemNode);
                        elemNode.InnerText = "1";
                    }
                    else if (MathMethods.IsNumber(ei[currentPos].Text))
                    {
                        elemNode = doc.CreateElement("ml:real", uri2);
                        elemNode.InnerText = ei[currentPos].Text;
                    }
                    else if (ei[currentPos].Text.Length >= 2 && ei[currentPos].Text[0] == '"' && ei[currentPos].Text[ei[currentPos].Text.Length - 1] == '"')
                    {
                        elemNode = doc.CreateElement("ml:str", uri2);
                        CreateXMLAttribute("xml:space", "preserve", doc, elemNode);
                        elemNode.InnerText = ei[currentPos].Text.Substring(1, ei[currentPos].Text.Length - 2);
                    }
                    else
                    {
                        elemNode = doc.CreateElement("ml:id", uri2);
                        CreateXMLAttribute("xml:space", "preserve", doc, elemNode);
                        if (ei[currentPos].Text[0] == '\'')
                            elemNode.InnerText = ei[currentPos].Text.Substring(1);
                        else
                            elemNode.InnerText = ei[currentPos].Text;
                    }

                    node.AppendChild(elemNode);
                }
                else if (ei[currentPos].Type == TermType.Operator)
                {
                    if (ei[currentPos].Text == Operators.NumericEqual)
                    {
                        XmlElement elemNode2;
                        if (region.Optimization == OptimizationType.Numeric)
                        {
                            elemNode = doc.CreateElement("ml:eval", uri2);
                            CreateXMLAttribute("placeholderMultiplicationStyle", "default", doc, elemNode);

                            node.AppendChild(elemNode);
                            RecurseFill(context, region, ei, 1, elemNode, doc);

                            // if units are define, use ml:unitOverride here!
                            if (region.Units != null)
                            {
                                int rememberCurrentPos = currentPos;
                                Term[] units = PostfixToPrefix(region.Units);
                                XmlElement elemNode3 = doc.CreateElement("ml:unitOverride", uri2);
                                currentPos = -1;
                                RecurseFill(context, region, units, 1, elemNode3, doc);
                                elemNode.AppendChild(elemNode3);
                                currentPos = rememberCurrentPos;
                            }

                            elemNode2 = doc.CreateElement("result", uri2);
                        }
                        else
                        {
                            elemNode = doc.CreateElement("ml:symEval", uri2);
                            CreateXMLAttribute("style", "default", doc, elemNode);
                            CreateXMLAttribute("hide-keywords", "false", doc, elemNode);
                            CreateXMLAttribute("hide-lhs", "false", doc, elemNode);

                            node.AppendChild(elemNode);
                            RecurseFill(context, region, ei, 1, elemNode, doc);

                            elemNode2 = doc.CreateElement("ml:symResult", uri2);
                        }
                        elemNode.AppendChild(elemNode2);
                        RecurseFill(context, region, ei, 1, elemNode2, doc);
                    }
                    else if (ei[currentPos].Text == Operators.Definition)
                    {
                        elemNode = doc.CreateElement("ml:define", uri2);
                        node.AppendChild(elemNode);
                        RecurseFill(context, region, ei, ei[currentPos].ArgsCount, elemNode, doc);
                    }
                    else
                    {
                        elemNode = doc.CreateElement("ml:apply", uri2);

                        if (ei[currentPos].Text == Operators.EmptyOperator)
                            elemNode.AppendChild(doc.CreateElement("ml:unknownOp", uri2));
                        else if (ei[currentPos].Text == Operators.BooleanEqual)
                            elemNode.AppendChild(doc.CreateElement("ml:equal", uri2));
                        else if (ei[currentPos].Text == Operators.BooleanLess)
                            elemNode.AppendChild(doc.CreateElement("ml:lessThan", uri2));
                        else if (ei[currentPos].Text == Operators.BooleanMore)
                            elemNode.AppendChild(doc.CreateElement("ml:greaterThan", uri2));
                        else if (ei[currentPos].Text == Operators.BooleanLessOrEqual)
                            elemNode.AppendChild(doc.CreateElement("ml:lessOrEqual", uri2));
                        else if (ei[currentPos].Text == Operators.BooleanMoreOrEqual)
                            elemNode.AppendChild(doc.CreateElement("ml:greaterOrEqual", uri2));
                        else if (ei[currentPos].Text == Operators.BooleanNotEqual)
                            elemNode.AppendChild(doc.CreateElement("ml:notEqual", uri2));
                        else if (ei[currentPos].Text == Operators.BooleanNot)
                            elemNode.AppendChild(doc.CreateElement("ml:not", uri2));
                        else if (ei[currentPos].Text == Operators.BooleanAnd)
                            elemNode.AppendChild(doc.CreateElement("ml:and", uri2));
                        else if (ei[currentPos].Text == Operators.BooleanOr)
                            elemNode.AppendChild(doc.CreateElement("ml:or", uri2));
                        else if (ei[currentPos].Text == Operators.BooleanXor)
                            elemNode.AppendChild(doc.CreateElement("ml:xor", uri2));
                        else if (ei[currentPos].Text == Operators.Factorial)
                            elemNode.AppendChild(doc.CreateElement("ml:factorial", uri2));
                        else if (ei[currentPos].Text == Operators.Composition)
                            elemNode.AppendChild(doc.CreateElement("ml:plus", uri2));
                        else if (ei[currentPos].Text == Operators.Subtraction)
                            elemNode.AppendChild(doc.CreateElement(ei[currentPos].ArgsCount == 2 ? "ml:minus" : "ml:neg", uri2));
                        else if (ei[currentPos].Text == Operators.Multiplication)
                            elemNode.AppendChild(doc.CreateElement("ml:mult", uri2));
                        else if (ei[currentPos].Text == Operators.Division)
                            elemNode.AppendChild(doc.CreateElement("ml:div", uri2));
                        else if (ei[currentPos].Text == Operators.Exponentiation)
                            elemNode.AppendChild(doc.CreateElement("ml:pow", uri2));
                        else if (ei[currentPos].Text == Operators.VectorMultiplication)
                            elemNode.AppendChild(doc.CreateElement("ml:crossProduct", uri2));
                        else
                            throw new NotSupportedException();

                        node.AppendChild(elemNode);
                        RecurseFill(context, region, ei, ei[currentPos].ArgsCount, elemNode, doc);
                    }
                }
                else if (ei[currentPos].Type == TermType.Function)
                {
                    if (ei[currentPos].Text == Functions.Mat)
                    {
                        elemNode = doc.CreateElement("ml:matrix", uri2);
                        node.AppendChild(elemNode);
                        RecurseFill(context, region, ei, ei[currentPos].ArgsCount - 2, elemNode, doc);

                        CreateXMLAttribute("rows", ei[++currentPos].Text, doc, elemNode);
                        CreateXMLAttribute("cols", ei[++currentPos].Text, doc, elemNode);
                    }
                    else if (ei[currentPos].Text == Functions.Diff)
                    {
                        elemNode = doc.CreateElement("ml:apply", uri2);

                        XmlElement elemNode2 = doc.CreateElement("ml:derivative", uri2);
                        elemNode.AppendChild(elemNode2);
                        XmlElement lambda = doc.CreateElement("ml:lambda", uri2);
                        elemNode.AppendChild(lambda);
                        XmlElement bound = doc.CreateElement("ml:boundVars", uri2);
                        lambda.AppendChild(bound);

                        RecurseFill(context, region, ei, ei[currentPos].ArgsCount - 1, lambda, doc);
                        RecurseFill(context, region, ei, 1, bound, doc);

                        node.AppendChild(elemNode);
                    }
                    else if (ei[currentPos].Text == Functions.Range)
                    {
                        elemNode = doc.CreateElement("ml:range", uri2);
                        node.AppendChild(elemNode);
                        RecurseFill(context, region, ei, ei[currentPos].ArgsCount, elemNode, doc);
                    }
                    else
                    {
                        elemNode = doc.CreateElement("ml:apply", uri2);

                        XmlElement elemNode2 = null;

                        if (ei[currentPos].Text == Functions.Abs)
                            elemNode2 = doc.CreateElement("ml:absval", uri2);
                        else if (ei[currentPos].Text == Functions.Sqrt)
                            elemNode2 = doc.CreateElement("ml:sqrt", uri2);
                        else if (ei[currentPos].Text == Functions.Nthroot)
                            elemNode2 = doc.CreateElement("ml:nthRoot", uri2);
                        else if (ei[currentPos].Text == Functions.Transpose)
                            elemNode2 = doc.CreateElement("ml:transpose", uri2);
                        else if (ei[currentPos].Text == Functions.Det)
                            elemNode2 = doc.CreateElement("ml:determinant", uri2);
                        else
                        {
                            elemNode2 = doc.CreateElement("ml:id", uri2);
                            CreateXMLAttribute("xml:space", "preserve", doc, elemNode2);
                            elemNode2.InnerText = ei[currentPos].Text;
                        }

                        elemNode.AppendChild(elemNode2);
                        node.AppendChild(elemNode);
                        RecurseFill(context, region, ei, ei[currentPos].ArgsCount, elemNode, doc);
                    }
                }
                else if (ei[currentPos].Type == TermType.Bracket)
                {
                    elemNode = doc.CreateElement("ml:parens", uri2);

                    node.AppendChild(elemNode);
                    RecurseFill(context, region, ei, ei[currentPos].ArgsCount, elemNode, doc);
                }
                else
                    throw new NotSupportedException();

                if (--childrenCount == 0)
                    return;
            }
        }

        private static Term[] MergeManyArrayPostfix(Term[][] value, int ind, int amount)
        {
            int length = 1;

            for (int i = 1; i <= amount; i++)
            {
                if (value[ind - i] != null)
                {
                    length += value[ind - i].Length;
                }
            }

            int shift = 0;
            Term[] result = new Term[shift + length];

            for (int i = 1; i <= amount; i++)
            {
                if (value[ind - i] != null)
                {
                    for (int y = 0; y < value[ind - i].Length; y++)
                    {
                        result[y + shift] = value[ind - i][y];
                    }

                    shift += value[ind - i].Length;
                }
            }

            return result;
        }

        private static Term[] MergeManyArrayPrefix(Term[][] value, int ind, int amount)
        {
            int length = 0;

            for (int i = 1; i <= amount; i++)
            {
                if (value[ind - i] != null)
                {
                    length += value[ind - i].Length;
                }
            }

            int shift = 1;
            Term[] result = new Term[shift + length];

            for (int i = amount; i > 0; --i)
            {
                if (value[ind - i] != null)
                {
                    for (int y = 0; y < value[ind - i].Length; y++)
                    {
                        result[y + shift] = value[ind - i][y];
                    }

                    shift += value[ind - i].Length;
                }
            }

            return result;
        }

        public static Term[] PrefixToPostfix(Term[] value)
        {
            Term[][] result = new Term[value.Length][];
            int ind = 0;

            for (int i = value.Length - 1; i >= 0; --i)
            {
                switch (value[i].Type)
                {
                    case TermType.Operand:
                        result[ind] = new Term[1];
                        result[ind][0] = value[i];
                        ind++;
                        break;
                    case TermType.Operator:
                    case TermType.Bracket:
                    case TermType.Function:
                        Term[] oper = MergeManyArrayPostfix(result, ind, value[i].ArgsCount);

                        oper[oper.Length - 1] = value[i];
                        ind -= value[i].ArgsCount;
                        result[ind] = oper;
                        ind++;

                        break;
                    default: break;
                }
            }

            return result[ind - 1];
        }

        public static Term[] PostfixToPrefix(Term[] value)
        {
            Term[][] result = new Term[value.Length][];
            int ind = 0;

            for (int i = 0; i < value.Length; ++i)
            {
                switch (value[i].Type)
                {
                    case TermType.Operand:
                        result[ind] = new Term[1];
                        result[ind][0] = value[i];
                        ind++;
                        break;
                    case TermType.Operator:
                    case TermType.Bracket:
                    case TermType.Function:
                        Term[] oper = MergeManyArrayPrefix(result, ind, value[i].ArgsCount);

                        oper[0] = value[i];
                        ind -= value[i].ArgsCount;
                        result[ind] = oper;
                        ind++;

                        break;
                    default: break;
                }
            }

            return result[ind - 1];
        }

        #endregion

        #region Private fields

        private FileType[] fileTypesHandled;

        #endregion

        #region IPluginOpenFileTypes Members

        bool IPluginOpenFileTypes.OpenFileType(Stream stream, List<RegionsList> regionsLists, FileContext context)
        {
            if (context.Extension == ".xmcd")
            {
                int errorsCount = 0;
                string errorText = "";
                errStrings = new List<string>();

                Dictionary<string, string> binaryItems = new Dictionary<string, string>();
                using (XmlReader Reader = XmlReader.Create(stream))
                {
                    while (Reader.Read())
                    {
                        Reader.MoveToContent();
                        if (Reader.NodeType == XmlNodeType.Element && Reader.Name == "regions")
                        {
                            Reader.Skip();

                            while (Reader.Read())
                            {
                                Reader.MoveToContent();
                                if (Reader.NodeType == XmlNodeType.Element && Reader.Name == "binaryContent")
                                    continue;
                                else if (Reader.NodeType == XmlNodeType.Element && Reader.Name == "item")
                                    binaryItems.Add(Reader.GetAttribute("item-id"), Reader.ReadElementString());
                                else if (Reader.NodeType == XmlNodeType.EndElement && Reader.Name == "binaryContent")
                                    break;
                            }

                            break;
                        }
                    }

                    stream.Position = 0;

                    using (XmlReader xmlReader = XmlReader.Create(stream))
                    {
                        xmlReader.Read();
                        // added 5 pixels to y to fix things up
                        int yAdd = 5;
                        var controls = new RegionsList(ContentPlacement.Main);
                        regionsLists.Add(controls);
                        OpenXMCD(context, xmlReader, ref errorsCount, ref yAdd, controls, binaryItems);
                    }
                }

                if (errorsCount > 0)
                {
                    // add a little nicer error report.
                    for (int i = 0; i < errStrings.Count; i++)
                        errorText += errStrings[i] + "\r";

                    context.RaiseError(String.Format(GeneralException.GetErrorText(context.SessionProfile, Errors.XMCDFileCanNotBeFullySaved), errorsCount.ToString()) + "\r" + errorText);
                    if (context.Cancel)
                        return false;
                }

                return true;
            }

            return false;
        }

        #endregion

        #region IPluginSaveFileTypes Members

        bool IPluginSaveFileTypes.SaveFileType(Stream stream, RegionsManager manager, FileContext context)
        {
            if (context.Extension == ".xmcd")
            {
                int errorsCount = 0;
                string errorText = "";
                errStrings = new List<string>();

                using (XmlTextWriter writer = new XmlTextWriter(stream, Encoding.UTF8))
                {
                    SaveToXMCD(context, writer, ref errorsCount, manager.Content);
                }

                if (errorsCount > 0)
                {
                    // add a little nicer error report.
                    for (int i = 0; i < errStrings.Count; i++)
                        errorText += errStrings[i] + "\r";

                    context.RaiseError(String.Format(GeneralException.GetErrorText(context.SessionProfile, Errors.XMCDFileCanNotBeFullySaved), errorsCount.ToString()) + "\r" + errorText);
                    if (context.Cancel)
                        return false;
                }

                return true;
            }

            return false;
        }

        #endregion

        #region IPluginHandleFileTypes Members

        FileType[] IPluginHandleFileTypes.FileTypesHandled
        {
            get { return this.fileTypesHandled; }
        }

        #endregion

        #region IPlugin Members

        void IPlugin.Initialize()
        {
            this.fileTypesHandled = new FileType[] {
                new FileType("Mathcad files", new string[] { ".xmcd" }, FileBehavior.Open | FileBehavior.Save),
            };
        }

        #endregion

        #region IDisposable Members

        void IDisposable.Dispose()
        {
        }

        #endregion

        #region XMCD Styles Class

        public class Styles
        {
            public string name = "Normal";
            public string fontfamily = "Times New Roman";
            public int fontsize = 10;
            public bool bold = false;
            public bool italics = false;
            public bool underline = false;
        }
        #endregion

        #region XMCD pagemodel Class

        private class PrintPageModel
        {
            public string show_page_frame = "false";
            public string show_header_frame = "false";
            public string show_footer_frame = "false";
            public string paper_code = "1";
            public string orientation = "portrait";
            public string print_single_page_width = "false";
            public int width = 0;
            public int height = 0;

            public _margins margins = new _margins();
            public _header header = new _header();
            public _footer footer = new _footer();

            public class _margins
            {
                public int left = 0;
                public int right = 0;
                public int top = 0;
                public int bottom = 0;
            }

            public class _header
            {
                public string left = "";
                public string center = "";
                public string right = "";
            }
            public class _footer
            {
                public string left = "";
                public string center = "";
                public string right = "";
            }
        }

        #endregion

        #region XMCD settings class

        // add this for default settings.
        private class Settings
        {
            public string defaultHighlightColor = "#ffff80";
            public string defaultBackgroundColor = "#ffffff";
            // original scale factor 1.28
            public double scaleFactor = 1.395;
        }

        #endregion

        #region Base64StringToImage and ImageToBase64String

        // These two functions taken from:
        //   http://social.msdn.microsoft.com/Forums/en/csharpgeneral/thread/ceb75a13-ed65-4981-a70d-5ace335feb0b

        private IBitmap Base64StringToImage(string base64ImageString)
        {
            // Fix for incorrectly composed base64 string
            if (base64ImageString.Length % 4 > 0)
                base64ImageString = base64ImageString.PadRight(base64ImageString.Length + 4 - base64ImageString.Length % 4, '=');

            var b = Convert.FromBase64String(base64ImageString);
            using (var ms = new MemoryStream(b))
            {
                return SessionsManager.Current.Specifics.StreamToBitmap(ms);
            }
        }

        private string ImageToBase64String(IBitmap imageData, BitmapFormat format)
        {
            using (var memory = new MemoryStream())
            {
                SessionsManager.Current.Specifics.BitmapToStream(imageData, memory, format);
                return System.Convert.ToBase64String(memory.ToArray());
            }
        }

        #endregion
    }
}