TEAMModelOS/TEAMModelOS.Service/Services/PowerPoint/Implement/PowerPointHelper.cs

using DocumentFormat.OpenXml;
using DocumentFormat.OpenXml.Drawing;
using DocumentFormat.OpenXml.Packaging;
using DocumentFormat.OpenXml.Presentation;
using HiTeachCC.Model.PowerPoint;
using System;
using System.Collections.Generic;
using System.Drawing;
using System.IO;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Xml;
using System.Xml.Linq;
using System.Xml.XPath;
using TEAMModelOS.SDK.Context.Constant;
using TEAMModelOS.SDK.Context.Exception;
using TEAMModelOS.SDK.Helper.Common.ColorHelper;
using TEAMModelOS.SDK.Helper.Common.StringHelper;
using TEAMModelOS.SDK.Helper.Security.ShaHash;
using TEAMModelOS.SDK.Module.AzureBlob.Container;
using TEAMModelOS.SDK.Module.AzureBlob.Interfaces;
using ColorMap = DocumentFormat.OpenXml.Presentation.ColorMap;
using Theme = DocumentFormat.OpenXml.Drawing.Theme;


namespace HiTeachCC.Service.PowerPoint.Implement
{
    public static class PowerPointHelper
    {
        public  static    XmlNamespaceManager xmlnsManager ;
        public static XmlNode GetTextByPath(this XmlDocument document , string expression) {
            return document.SelectSingleNode(expression , xmlnsManager);
        }
        public static XmlNode GetTextByPath(this XmlNode node, string expression)
        {
            
            return node.SelectSingleNode(expression, xmlnsManager);
        }
       

        public static XmlNodeList GetTextByPathList(this XmlDocument document, string expression)
        {
            return document.SelectNodes(expression, xmlnsManager);
        }
        public static XmlNodeList GetTextByPathList(this XmlNode node, string expression)
        {
            return node.SelectNodes(expression, xmlnsManager);
        }


        static PowerPointHelper()
        {
            xmlnsManager = new XmlNamespaceManager(new NameTable());
            xmlnsManager.AddNamespace("p", "http://schemas.openxmlformats.org/presentationml/2006/main");
            xmlnsManager.AddNamespace("a", "http://schemas.openxmlformats.org/drawingml/2006/main");
            xmlnsManager.AddNamespace("xsl", "http://www.w3.org/1999/XSL/Transform");
            xmlnsManager.AddNamespace("fo", "http://www.w3.org/1999/XSL/Format");
            xmlnsManager.AddNamespace("app", "http://schemas.openxmlformats.org/officeDocument/2006/extended-properties");
            xmlnsManager.AddNamespace("cp", "http://schemas.openxmlformats.org/package/2006/metadata/core-properties");
            xmlnsManager.AddNamespace("dc", "http://purl.org/dc/elements/1.1/");
            xmlnsManager.AddNamespace("dcterms", "http://purl.org/dc/terms/");
            xmlnsManager.AddNamespace("dcmitype", "http://purl.org/dc/dcmitype/");
            xmlnsManager.AddNamespace("rel", "http://schemas.openxmlformats.org/package/2006/relationships");
            xmlnsManager.AddNamespace("r", "http://schemas.openxmlformats.org/officeDocument/2006/relationships");
            xmlnsManager.AddNamespace("cus", "http://schemas.openxmlformats.org/officeDocument/2006/custom-properties");
            xmlnsManager.AddNamespace("vt", "http://schemas.openxmlformats.org/officeDocument/2006/docPropsVTypes");
            xmlnsManager.AddNamespace("pic", "http://schemas.openxmlformats.org/drawingml/2006/picture");
            xmlnsManager.AddNamespace("dsp", "http://schemas.microsoft.com/office/drawing/2008/diagram");
            xmlnsManager.AddNamespace("dgm", "http://schemas.openxmlformats.org/drawingml/2006/diagram");
            xmlnsManager.AddNamespace("a14", "http://schemas.microsoft.com/office/drawing/2010/main");
            xmlnsManager.AddNamespace("m", "http://schemas.openxmlformats.org/officeDocument/2006/math");
            xmlnsManager.AddNamespace("mc", "http://schemas.openxmlformats.org/markup-compatibility/2006");
            xmlnsManager.AddNamespace("p14", "http://schemas.microsoft.com/office/powerpoint/2010/main");
            xmlnsManager.AddNamespace("pkg", "http://schemas.microsoft.com/office/2006/xmlPackage");
            xmlnsManager.AddNamespace("p15", "http://schemas.microsoft.com/office/powerpoint/2012/main");
            xmlnsManager.AddNamespace("a16", "http://schemas.microsoft.com/office/drawing/2014/main");
            xmlnsManager.AddNamespace("xsi", "http://www.w3.org/2001/XMLSchema-instance");
            xmlnsManager.AddNamespace("c", "http://schemas.openxmlformats.org/drawingml/2006/chart");
            xmlnsManager.AddNamespace("c14", "http://schemas.microsoft.com/office/drawing/2007/8/2/chart");
            xmlnsManager.AddNamespace("c16", "http://schemas.microsoft.com/office/drawing/2014/chart");
            xmlnsManager.AddNamespace("cs", "http://schemas.microsoft.com/office/drawing/2012/chartStyle");
            xmlnsManager.AddNamespace("thm15", "http://schemas.microsoft.com/office/thememl/2012/main");
            xmlnsManager.AddNamespace("fn", "http://www.w3.org/2005/xpath-functions");
        }


      public static async Task<AzureBlobModel>SaveBase64ToBolob(string data, string contentType ,string FolderName ,string fileName , IAzureBlobDBRepository azureBlobDBRepository ) {
            string fileExt ;
            if (ContentTypeDict.extdict.TryGetValue(contentType, out string ext))
            {
                fileExt = ext;
            }
            else
            {
                //解决多种扩展名不能获取的
                string[] sp = contentType.Split("/");
                fileExt = sp[sp.Length - 1];
                sp = fileExt.Split("+");
                fileExt = "." + sp[sp.Length - 1];
            }
            //data:image/jpeg;base64,
            try {
                if (string.IsNullOrEmpty(fileName))
                {
                    Stream stream = new MemoryStream(Convert.FromBase64String(data));
                    string shaCode = ShaHashHelper.GetSHA1(stream);
                    fileName = shaCode + fileExt;
                }
                else {
                    if (fileName.Split(".").Length == 1) {
                        fileName += fileExt;
                    }
                }
                Stream streamBlob = new MemoryStream(Convert.FromBase64String(data));
                AzureBlobModel model = await azureBlobDBRepository.UploadFileByFolder(streamBlob, FolderName + "/imgs", fileName, "pptx", false);
                return model;
            } catch (Exception x) {

                throw new BizException(x.Message);          }
        }
        public static void GenPPTXShape(XmlNode shapeType)
        {
            string svgPath = "";
            switch (shapeType.Value)
            {
                //线形标注 1(带边框和强调线) 
                case "accentBorderCallout1": break;
                //线形标注 2(带边框和强调线) 
                case "accentBorderCallout2": break;
                //线形标注 3(带边框和强调线) 
                case "accentBorderCallout3": break;
                //线形标注 1(带强调线)
                case "accentCallout1": break;
                //线形标注 2(带强调线)
                case "accentCallout2": break;
                //线形标注 3(带强调线)
                case "accentCallout3": break;
                //动作按钮后退或前一项
                case "actionButtonBackPrevious": break;
                //动作按钮开始
                case "actionButtonBeginning": break;
                //按钮自定义
                case "actionButtonBlank": break;
                //动作按钮文档
                case "actionButtonDocument": break;
                //动作按钮 结束
                case "actionButtonEnd": break;
                //动作按钮前进下一项
                case "actionButtonForwardNext": break;
                // 动作按钮帮助
                case "actionButtonHelp": break;
                // 动作按钮 第一张 
                case "actionButtonHome": break;
                // 动作按钮 信息
                case "actionButtonInformation": break;
                //动作按钮 视频
                case "actionButtonMovie": break;
                //动作按钮返回
                case "actionButtonReturn": break;
                //动作按钮 音频
                case "actionButtonSound": break;
                //弧形  圆弧 弧线
                case "arc": break;
                //棱台  TODO
                case "bevel": break;
                // 空心弧 TODO
                case "blockArc": break;
                //线形标注 1
                case "borderCallout1": break;
                //线形标注 2
                case "borderCallout2": break;
                //线形标注 3
                case "borderCallout3": break;
                //大括号 对 {}
                case "bracePair": break;
                //括号 对()
                case "bracketPair": break;
                //callout1线形标注 1(无边框)
                case "callout1": break;
                //callout1线形标注 2(无边框)
                case "callout2": break;
                //callout1线形标注 3(无边框)
                case "callout3": break;
                // 圆柱型  TODO暂不解析
                case "can": break;
                // 符号 +
                case "chartPlus": break;
                //符号 * 
                case "chartStar": break;
                //符号x
                case "chartX": break;
                //燕尾形 长：3：1  左边缺一个单位的三角形 右边多一个单位三角形
                case "chevron": break;
                //弦形
                case "chord": break;
                //  云形 宽高比例拉伸
                case "cloud": break;
                //云形标注 
                case "cloudCallout": break;
                // L 形
                case "corner": break;
                //角形 标签 github 角形
                case "cornerTabs": break;
                //立方体 TODO
                case "cube": break;
                //十边形
                case "decagon": break;
                ////斜纹 斜梯形
                case "diagStripe": break;
                //菱形
                case "diamond": break;
                //十二边形
                case "dodecagon": break;
                //同心圆 TODO
                case "donut": break;
                //双波形
                case "doubleWave": break;
                //下箭头标注 
                case "downArrowCallout": break;
                //前凸弯带形 
                case "ellipseRibbon": break;
                //上凸弯带形 8
                case "ellipseRibbon2": break;
                //可选过程 圆角矩形
                case "flowChartAlternateProcess": break;
                //对照 长宽2：1 两个等腰三角形 上下尖对尖
                case "flowChartCollate": break;
                //接点 圆形
                case "flowChartConnector": break;
                //决策  菱形
                case "flowChartDecision": break;
                //延期正方形右侧多个半圆
                case "flowChartDelay": break;
                //显示  正方形 左侧1/4高度等腰三角形 1/4右侧弧形
                case "flowChartDisplay": break;
                //文档 矩形 下面部分波浪
                case "flowChartDocument": break;
                //摘录  正方形里面的等腰三角形 向上
                case "flowChartExtract": break;
                //数据  平行四边形
                case "flowChartInputOutput": break;
                //内部贮存 左上角横竖各一条线
                case "flowChartInternalStorage": break;
                //磁盘 圆柱体 向上 宽高 2：1 压扁
                case "flowChartMagneticDisk": break;
                //直接访问存储器 圆柱体 平躺 宽高 2：1 拉长
                case "flowChartMagneticDrum": break;
                //顺序访问存储器 圆形  小猪佩奇 下面多个矩形
                case "flowChartMagneticTape": break;
                //手动输入  矩形 上面部分向左倾斜一点 倾斜高度四分之一
                case "flowChartManualInput": break;
                //手动操作 倒等腰梯形
                case "flowChartManualOperation": break;
                //合并 正方形里面的等腰三角形 向下
                case "flowChartMerge": break;
                // 多文档 3个矩形 下面部分波浪 叠加
                case "flowChartMultidocument": break;
                //flowChartOfflineStorage 离线存储
                case "flowChartOfflineStorage": break;
                //离页连接符 正方形 左下角右下角各缺角一边高度为四分之一，一边长为一半的的三角形
                case "flowChartOffpageConnector": break;
                //存储数据  矩形  左侧多个半圆 右侧缺半圆
                case "flowChartOnlineStorage": break;
                //或者 圆形经过圆形 两条横竖交叉的直线
                case "flowChartOr": break;
                //预定义过程  矩形 左右部分各有一条竖线
                case "flowChartPredefinedProcess": break;
                //准备 六边形 上下被压缩变长2倍边
                case "flowChartPreparation": break;
                //流程图  矩形
                case "flowChartProcess": break;
                //卡片 矩形右上角剪角最小宽度的1/4的三角形
                case "flowChartPunchedCard": break;
                //资料带 波浪形
                case "flowChartPunchedTape": break;
                // 排序 两个等腰三角形 背对背 长宽2：1
                case "flowChartSort": break;
                //汇总连接 圆形经过圆形 两条斜交叉的直线
                case "flowChartSummingJunction": break;
                //终止 最小边半径圆角矩形
                case "flowChartTerminator": break;
                //折角
                case "folderCorner": break;
                //  图文框框
                case "frame": break;
                //漏斗
                case "funnel": break;
                //齿轮六角
                case "gear6": break;
                //齿轮9角
                case "gear9": break;
                // 半闭框
                case "halfFrame": break;
                //心形  宽高拉伸
                case "heart": break;
                ////七边形
                case "heptagon": break;
                //六边形1060704 *96/914400=111.36
                case "hexagon": break;
                //五边形  长高 2：1 矩形加右侧1一个宽的三角形
                case "homePlate": break;
                //横卷形
                case "horizontalScroll": break;
                //爆炸形1
                case "irregularSeal1": break;
                //爆炸形2
                case "irregularSeal2": break;
                //左箭头
                case "leftArrow": break;
                //左箭头标注
                case "leftArrowCallout": break;
                //左大括号{
                case "leftBrace": break;
                //左括号(
                case "leftBracket": break;
                //左右箭头标注
                case "leftRightArrowCallout": break;
                //左右凸出带
                case "leftRightRibbon": break;
                // 闪电 宽高拉伸
                case "lightningBolt": break;
                case "lineInv": break;
                //除号
                case "mathDivide": break;
                //等号
                case "mathEqual": break;
                //减号
                case "mathMinus": break;
                //乘号
                case "mathMultiply": break;
                //不等号
                case "mathNotEqual": break;
                //加号
                case "mathPlus": break;
                //新月形
                case "moon": break;
                //非等腰梯形
                case "nonIsoscelesTrapezoid": break;
                //禁止吸烟
                case "noSmoking": break;
                // 八边形
                case "octagon": break;
                //平行四边形   
                case "parallelogram": break;
                //正五边形  宽高决定形变
                case "pentagon": break;
                ////饼图  21600000   16200000    默认16200000  ---> 0
                case "pie": break;
                //扇形边 扇形
                case "pieWedge": break;
                //缺角圆角矩形
                case "plaque": break;
                //缺角 圆角标签
                case "plaqueTabs": break;
                //十字形
                case "plus": break;
                // 十字箭头标注
                case "quadArrowCallout": break;
                //矩形
                case "rect":
                    svgPath = "<rect rx=\"37.5\" ry=\"37.5\" width=\"150\" height=\"150\" style=\"fill:red;\" />";
                    break;
                //前凸带形
                case "ribbon": break;
                //上凸带形
                case "ribbon2": break;
                //右箭头标注
                case "rightArrowCallout": break;
                //右大括号}
                case "rightBrace": break;
                //右括号)
                case "rightBracket": break;
                //单圆角矩形 右上角圆角缺角 0-50000 = 50% 最小宽度的 百分比作为缺角
                case "round1Rect": break;
                // 对角圆角矩形 左上角 右下角 圆角缺角0-50000 = 50% 最小宽度的 百分比作为缺角  右上角 左下角 圆角缺角0-50000 = 50% 最小宽度的 百分比作为缺角
                case "round2DiagRect": break;
                //同侧圆角矩形
                case "round2SameRect": break;
                //直角三角形  宽高决定形变
                case "rtTriangle": break;
                //笑脸
                case "smileyFace": break;
                //剪去单角的矩形 右上角  0-50000 = 50% 最小宽度的 百分比作为缺角
                case "snip1Rect": break;
                //剪去对角的矩形  
                case "snip2DiagRect": break;
                //剪去同侧角的矩形
                case "snip2SameRect": break;
                //单圆角矩形
                case "snipRoundRect": break;
                //方形制表符  不解析
                case "squareTabs": break;
                // 十角星
                case "star10": break;
                // 12角星
                case "star12": break;
                // 16角星
                case "star16": break;
                // 24角星
                case "star24": break;
                // 32角星
                case "star32": break;
                // 4角星
                case "star4": break;
                // 5角星
                case "star5": break;
                // 6角星
                case "star6": break;
                // 7角星
                case "star7": break;
                // 8角星
                case "star8": break;
                // 太阳
                case "sun": break;
                //泪滴型 
                case "teardrop": break;
                //等腰梯形
                case "trapezoid": break;
                //上箭头标注
                case "upArrowCallout": break;
                //上下箭头标注
                case "upDownArrowCallout": break;
                //竖卷形 
                case "verticalScroll": break;
                //波浪形
                case "wave": break;
                //椭圆形标注
                case "wedgeEllipseCallout": break;
                // 矩形标注
                case "wedgeRectCallout": break;
                // 圆角矩形标注
                case "wedgeRoundRectCallout": break;
                // //椭圆或者圆形
                case "ellipse":
                    svgPath = " <circle cx=\"100\" cy=\"50\" r=\"40\" stroke=\"black\" stroke-width=\"2\" fill=\"red\" />";
                    break;
                // 圆角矩形
                case "roundRect": break;

                case "bentConnector2": break;
                //直接连接符 线
                case "line":
                    svgPath = " <line x1=\"0\" y1=\"0\" x2=\"200\" y2=\"200\" style=\"stroke:blue;stroke-width:1\" />";

                    break;
                //直接箭头连接符
                case "straightConnector1": break;
                //肘形连接符<a:headEnd type="triangle"/>
                //  < a:tailEnd type = "triangle" />
                case "bentConnector3": break;
                //肘形箭头连接符
                //  case "bentConnector4": break;
                //肘形双箭头连接符
                // case "bentConnector5": break;

                // case "curvedConnector2": break;
                //曲线连接符
                case "curvedConnector3": break;
                // case "curvedConnector4": break;
                // case "curvedConnector5": break;
                //右箭头
                case "rightArrow": break;
                //下箭头
                case "downArrow": break;
                //圆角右箭头 
                case "bentArrow": break;
                //直角上箭头
                case "bentUpArrow": break;
                //虚尾箭头
                case "stripedRightArrow": break;
                //十字箭头  TODO
                case "quadArrow": break;
                //环形箭头
                case "circularArrow": break;
                case "swooshArrow": break;
                // //左右箭头
                case "leftRightArrow": break;
                //丁字箭头
                case "leftRightUpArrow": break;
                //直角双向箭头 向左 向上
                case "leftUpArrow": break;
                //左环形箭头
                case "leftCircularArrow": break;
                //燕尾形箭头
                case "notchedRightArrow": break;
                //上弧形箭头 弧形向上 箭头右下
                case "curvedDownArrow": break;
                //右弧形箭头 弧形向右 箭头向左下
                case "curvedLeftArrow": break;
                //左弧形箭头 弧形向左 箭头向右下
                case "curvedRightArrow": break;
                //下弧形箭头 弧形向下 箭头右上
                case "curvedUpArrow": break;
                //上下箭头
                case "upDownArrow": break;
                //上箭头
                case "upArrow": break;
                //手杖形箭头 向右调头
                case "uturnArrow": break;
                //左右圆箭头
                case "leftRightCircularArrow": break;
                //三角形
                case "triangle": break;
                default: break;
            }
        }

        public static string GetFontColor(XmlDocument nodeXml, XmlNode typeNode, XmlDocument slideMasterTextStyles, Dictionary<string, string> colors)
        {
            var color = nodeXml.SelectSingleNode("//a:rPr/a:solidFill/a:srgbClr/@val", xmlnsManager);
            if (color == null && typeNode != null)
            {
                if (typeNode.Value.Equals("title") || typeNode.Value.Equals("subTitle") || typeNode.Value.Equals("ctrTitle"))
                {
                    color = slideMasterTextStyles.SelectSingleNode("//p:titleStyle/a:lvl1pPr/a:defRPr/a:solidFill/a:schemeClr/@val", xmlnsManager);
                }
                if (typeNode.Value.Equals("body"))
                {
                    color = slideMasterTextStyles.SelectSingleNode("//p:bodyStyle/a:lvl1pPr/a:defRPr/a:solidFill/a:schemeClr/@val", xmlnsManager);
                }
                //if (typeNode.Value.Equals("dt") || typeNode.Value.Equals("sldNum"))
                //{
                //    color = 12;
                //}
            }
            if (color == null && typeNode == null)
            {
                color = slideMasterTextStyles.SelectSingleNode("//p:otherStyle/a:lvl1pPr/a:defRPr/a:solidFill/a:schemeClr/@val", xmlnsManager);
            }
            if (color != null)
            {
                if (colors.TryGetValue(color.Value, out string colr))
                {
                    return colr;
                }
                else { return "000000"; }
            }
            else { return "000000"; }

        }
        public static int GetFontSize(XmlDocument nodeXml, XmlDocument slideLayoutSpNode, XmlDocument slideMasterSpNode, XmlNode typeNode, XmlDocument slideMasterTextStyles)
        {

            int fontSize = 0;
            XmlNode szNode = nodeXml.SelectSingleNode("//a:rPr/@sz", xmlnsManager);
            if (szNode == null)
            {
                if (slideLayoutSpNode != null)
                {
                    szNode = slideLayoutSpNode.SelectSingleNode("//p:txBody/a:lstStyle/a:lvl1pPr/a:defRPr/@sz", xmlnsManager);
                }
            }
            if (szNode == null && typeNode != null)
            {
                if (typeNode.Value.Equals("title") || typeNode.Value.Equals("subTitle") || typeNode.Value.Equals("ctrTitle"))
                {
                    szNode = slideMasterTextStyles.SelectSingleNode("//p:titleStyle/a:lvl1pPr/a:defRPr/@sz", xmlnsManager);
                }
                if (typeNode.Value.Equals("body"))
                {
                    szNode = slideMasterTextStyles.SelectSingleNode("//p:bodyStyle/a:lvl1pPr/a:defRPr/@sz", xmlnsManager);
                }
                //if (typeNode.Value.Equals("dt") || typeNode.Value.Equals("sldNum"))
                //{
                //    fontSize = 12;
                //}
            }
            if (szNode == null && typeNode == null)
            {
                szNode = slideMasterTextStyles.SelectSingleNode("//p:otherStyle/a:lvl1pPr/a:defRPr/@sz", xmlnsManager);
            }
            if (szNode != null)
            {
                fontSize = int.Parse(szNode.Value) / 100;
            }
            XmlNode baseline = nodeXml.SelectSingleNode("//a:rPr/@baseline", xmlnsManager);
            if (baseline != null)
            {
                fontSize -= 10;
            }
            return fontSize;
            //font-size
        }
        public static string GetFontType(XmlDocument nodeXml, XmlNode typeNode, XmlDocument slideMasterTextStyles, Theme theme)
        {
            XmlNode typeface = nodeXml.SelectSingleNode("//a:rPr/a:latin/@typeface",xmlnsManager);
            if (typeface == null)
            {
                XmlDocument doc = new XmlDocument();
                doc.LoadXml(theme.OuterXml);
                typeface = doc.SelectSingleNode("//a:theme/a:themeElements/a:fontScheme/a:majorFont/a:latin/@typeface", xmlnsManager);
            }
            if (typeface != null)
            {
                return typeface.Value;
            }
            else
            {
                return "";
            }
            //font-family
        }
        public static string GetFontBold(XmlDocument nodeXml, XmlNode typeNode, XmlDocument slideMasterTextStyles)
        {
            var FontBold = nodeXml.SelectSingleNode("a:rPr/@b",xmlnsManager);
            if (FontBold != null)
            {
                if (FontBold.Value.Equals("1"))
                {
                    return "bold";
                }
                else
                {

                    return "initial";
                }
            }
            else
            {
                return "initial";
            }
            //font-weight
        }
        public static string GetFontItalic(XmlDocument nodeXml, XmlNode typeNode, XmlDocument slideMasterTextStyles)
        {
            var FontBold = nodeXml.SelectSingleNode("a:rPr/@i",xmlnsManager);
            if (FontBold != null)
            {
                if (FontBold.Value.Equals("1"))
                {
                    return "italic";
                }
                else
                {
                    return "normal";
                }
            }
            else
            {
                return "normal";
            }
            //font-style

        }
        public static string GetFontDecoration(XmlDocument nodeXml, XmlNode typeNode, XmlDocument slideMasterTextStyles)
        {
            var FontBold = nodeXml.SelectSingleNode("a:rPr/@u",xmlnsManager);
            if (FontBold != null)
            {
                if (FontBold.Value.Equals("sng"))
                {
                    return "underline";
                }
                else
                {

                    return "initial";
                }
            }
            else
            {
                return "initial";
            }
            //text-decoration
        }
        public static string GetTextVerticalAlign(XmlDocument nodeXml, XmlNode typeNode, XmlDocument slideMasterTextStyles)
        {
            var baseline = nodeXml.SelectSingleNode("a:rPr/@baseline",xmlnsManager);
            if (baseline != null)
            {
                return int.Parse(baseline.Value) / 1000 + "%";
            }
            else
            {
                return "baseline";
            }
            //vertical-align
        }
        /// <summary>
        /// 解析形状的填充色
        /// </summary>
        /// <param name="nodeXml"></param>
        /// <param name="colors"></param>
        /// <returns></returns>
        public static Model.PowerPoint.Fill GetShapeFill(string nodeXml, Dictionary<string, string> colors)
        {
            // 1. presentationML
            // p:spPr [a:noFill, solidFill, gradFill, blipFill, pattFill, grpFill]
            // From slide
            XmlDocument doc = new XmlDocument();
            doc.LoadXml(nodeXml);
            XmlNode nofillNode = doc.SelectSingleNode("//p:spPr/a:noFill", xmlnsManager);
            if (nofillNode != null)
            {
                return new Model.PowerPoint.Fill() { Type = 0, };
            }
            Model.PowerPoint.Fill fill = new Model.PowerPoint.Fill();
            string fillColor = null;
            XmlNode fillNode = doc.SelectSingleNode("//p:spPr/a:solidFill/a:srgbClr/@val", xmlnsManager);
            if (fillNode == null)
            {
                fillNode = doc.SelectSingleNode("//p:spPr/a:solidFill/a:schemeClr/@val", xmlnsManager);
            }
            if (fillNode == null)
            {
                fillNode = doc.SelectSingleNode("//p:style/a:fillRef/a:schemeClr/@val", xmlnsManager);
            }
            if (fillNode != null)
            {
                if (colors.TryGetValue(fillNode.Value, out string color))
                {
                    fillColor = color;
                }
                else
                {
                    fillColor = fillNode.Value;
                }

                var node = doc.SelectSingleNode("//p:spPr/a:solidFill/a:schemeClr | //p:style/a:fillRef/a:schemeClr", xmlnsManager);
                if (node != null && node.HasChildNodes)
                {
                    //调和颜色
                    fillColor = ColorToning(node.OuterXml, fillColor);
                }
                //调和颜色

            }
            return new Model.PowerPoint.Fill { Type =1, Color = fillColor };
        }
        /// <summary>
        /// 获取边框样式
        /// </summary>
        /// <param name="nodeXml"></param>
        /// <param name="isSvg"></param>
        public static Border GetBorder(string nodeXml, bool isCxnSp, Dictionary<string, string> colorMaps)
        {
            //边框宽度
            int borderWidth =0;
            if (isCxnSp) {
                borderWidth = 1;
            }
            XmlDocument doc = new XmlDocument();
            doc.LoadXml(nodeXml);
            XmlNode borderw = doc.SelectSingleNode("//p:spPr/a:ln/@w", xmlnsManager);
            if (borderw != null)
            {
                borderWidth = int.Parse(borderw.Value) / 12700;
            }
            //边框颜色
            string borderColor = null;
            XmlNode borderc = doc.SelectSingleNode("//p:spPr/a:ln/a:solidFill/a:srgbClr/@val", xmlnsManager);
            if (borderc == null)
            {
                borderc = doc.SelectSingleNode("//p:spPr/a:ln/a:solidFill/a:schemeClr/@val", xmlnsManager);
            }
            if (borderc == null)
            {
                borderc = doc.SelectSingleNode("//p:style/a:lnRef/a:schemeClr/@val", xmlnsManager);
            }
            if (borderc != null)
            {
                if (colorMaps.TryGetValue(borderc.Value, out string color))
                {
                    borderColor = color;
                }
                else
                {
                    borderColor = borderc.Value;
                }
                var node = doc.SelectSingleNode("//p:style/a:lnRef/a:schemeClr | //p:spPr/a:ln/a:solidFill/a:schemeClr", xmlnsManager);
                if (node != null && node.HasChildNodes)
                {
                    //调和颜色
                    borderColor = ColorToning(node.OuterXml, borderColor);
                }
            }

            //边框类型
            XmlNode borderT = doc.SelectSingleNode("//p:spPr/a:ln/a:prstDash/@val", xmlnsManager);
            var strokeDasharray = "0";
            var borderType = "";
            if (borderT != null)
            {
                switch (borderT.Value)
                {
                    case "solid":
                        borderType += "solid";
                        strokeDasharray = "0";
                        break;
                    case "dash":
                        borderType += "dashed";
                        strokeDasharray = "20";
                        break;
                    case "dashDot":
                        borderType += "dashed";
                        strokeDasharray = "5, 5, 1, 5";
                        break;
                    case "dot":
                        borderType += "dotted";
                        strokeDasharray = "1, 5";
                        break;
                    case "lgDash":
                        borderType += "dashed";
                        strokeDasharray = "10, 5";
                        break;
                    case "lgDashDotDot":
                        borderType += "dashed";
                        strokeDasharray = "10, 5, 1, 5, 1, 5";
                        break;
                    case "sysDash":
                        borderType += "dashed";
                        strokeDasharray = "5, 2";
                        break;
                    case "sysDashDot":
                        borderType += "dashed";
                        strokeDasharray = "5, 2, 1, 5";
                        break;
                    case "sysDashDotDot":
                        borderType += "dashed";
                        strokeDasharray = "5, 2, 1, 5, 1, 5";
                        break;
                    case "sysDot":
                        borderType += "dotted";
                        strokeDasharray = "2, 5";
                        break;
                    case null:
                    //console.log(borderType);
                    default:
                        break;
                        //console.warn(borderType);
                        //cssText += "#000 solid";
                }
            }

            if (isCxnSp)
            {
                borderWidth = borderWidth == 0 ? 1 : borderWidth;
                return new Border { Width = borderWidth, Color = borderColor, Type = borderType, Stroke = strokeDasharray };
            }
            else {
                if (string.IsNullOrEmpty(borderType) )
                {
                    if (borderWidth == 0)
                    {
                        return new Border { Width = 0, Color = borderColor, Type = borderType, Stroke = strokeDasharray };
                    }
                    else {
                        return new Border { Width = borderWidth, Color = borderColor, Type = "solid", Stroke = "0" };
                    }
                }
                else
                {
                    borderWidth = borderWidth == 0 ? 1 : borderWidth;
                    return new Border { Width = borderWidth, Color = borderColor, Type = borderType, Stroke = strokeDasharray };
                }
            }
           
            
        }
        /// <summary>
        /// 调色补充 Shade Tint  LumMod LumOff 等
        /// </summary>
        /// <param name="xml"></param>
        /// <param name="color"></param>
        /// <returns></returns>
        public static string ColorToning(string nodeXml, string colorHex)
        {
            TEAMModelOS.SDK.Helper.Common.ColorHelper.ColorConverter converter = new TEAMModelOS.SDK.Helper.Common.ColorHelper.ColorConverter();
            XmlDocument doc = new XmlDocument();
            doc.LoadXml(nodeXml);
            XmlNode lumMod = doc.SelectSingleNode("//a:lumMod/@val", xmlnsManager);
            if (lumMod != null)
            {
                colorHex = converter.SetLuminanceMod(colorHex, double.Parse(lumMod.Value));
            }
            XmlNode lumOff = doc.SelectSingleNode("//a:lumOff/@val", xmlnsManager);
            if (lumOff != null)
            {
                colorHex = converter.SetLuminanceOff(colorHex, double.Parse(lumOff.Value));
            }
            XmlNode satMod = doc.SelectSingleNode("//a:satMod/@val", xmlnsManager);
            if (satMod != null)
            {
                colorHex = converter.SetSaturationMod(colorHex, double.Parse(satMod.Value));
            }
            XmlNode satOff = doc.SelectSingleNode("//a:satOff/@val", xmlnsManager);
            if (satOff != null)
            {
                colorHex = converter.SetSaturationOff(colorHex, double.Parse(satOff.Value));
            }
            XmlNode hueOff = doc.SelectSingleNode("//a:hueOff/@val", xmlnsManager);
            if (hueOff != null)
            {
                colorHex = converter.SetHueOff(colorHex, double.Parse(hueOff.Value));
            }
            XmlNode hueMod = doc.SelectSingleNode("//a:hueMod/@val", xmlnsManager);
            if (hueMod != null)
            {
                colorHex = converter.SetHueMod(colorHex, double.Parse(hueMod.Value));
            }
            XmlNode alphaOff = doc.SelectSingleNode("//a:alphaOff/@val", xmlnsManager);
            if (alphaOff != null)
            {
                // Color color= ColorTranslator.FromHtml("#" + colorHex);
                //   color = Color.FromArgb(byte.Parse(int.Parse(alpha.Value)/100000+""),color.R,color.G,color.B);
            }
            XmlNode shade = doc.SelectSingleNode("//a:shade/@val", xmlnsManager);
            if (shade != null)
            {
                colorHex = converter.SetShade(colorHex, double.Parse(shade.Value));
            }
            XmlNode tint = doc.SelectSingleNode("//a:tint/@val", xmlnsManager);
            if (tint != null)
            {
                colorHex = converter.SetTint(colorHex, double.Parse(tint.Value));
            }
            XmlNode alpha = doc.SelectSingleNode("//a:alpha/@val", xmlnsManager);
            if (alpha != null)
            {
                // Color color= ColorTranslator.FromHtml("#" + colorHex);
                //   color = Color.FromArgb(byte.Parse(int.Parse(alpha.Value)/100000+""),color.R,color.G,color.B);
            }

            return colorHex;
        }

        public static Dictionary<string, string> GetLayoutOrMasterColors(SlidePart slidePart, Dictionary<string, string> slideMasterColors, Theme theme)
        {

            OverrideColorMapping colorMap = slidePart.SlideLayoutPart.SlideLayout.ColorMapOverride.OverrideColorMapping;
            Dictionary<string, string> Colors = new Dictionary<string, string>();
            if (colorMap != null)
            {
                Colors = DoColorMap(colorMap, null, theme);
            }
            else
            {
                Colors = slideMasterColors;
            }
            return Colors;
        }

        /// <summary>
        /// 根据 node layout master获取位置
        /// </summary>
        /// <param name="nodeXml"></param>
        /// <param name="slideLayoutSpNode"></param>
        /// <param name="slideMasterSpNode"></param>
        /// <returns></returns>
        public static HiTeachCC.Model.PowerPoint.Position GetPosition(string nodeXml, XmlDocument slideLayoutSpNode, XmlDocument slideMasterSpNode)
        {
            XmlDocument doc = new XmlDocument();
            doc.LoadXml(nodeXml);
            XmlNode xfrm = doc.SelectSingleNode("//a:xfrm", xmlnsManager);
            if (xfrm == null)
            {
                xfrm = slideLayoutSpNode.SelectSingleNode("//a:xfrm", xmlnsManager);
                if (xfrm == null)
                {
                    xfrm = slideMasterSpNode.SelectSingleNode("//a:xfrm",xmlnsManager);
                }

            }
            if (xfrm != null)
            {
                Transform2D transform2D = new Transform2D(xfrm.OuterXml);
                return GetPositionByTransform2D(transform2D);
            }
            return new Model.PowerPoint.Position();
        }

        public static BuChar GenBuChar(XmlDocument nodeXml, Style slideLayoutTables,
            Style slideMasterTables, XmlDocument SlideMasterTextStyles, XmlNode typeNode, bool hasBuChar)
        {


            // todo
            //需要完善slideMaster1.xml 中含有a:buChar 的情况

            //XmlDocument doc = new XmlDocument();
            //doc.LoadXml(nodeXml);
            BuChar bchar = new BuChar();
            // XmlNode pPr = nodeXml.SelectSingleNode("//a:pPr",xmlnsManager);
            int lvl = 0;
            XmlNode lvlNode = nodeXml.SelectSingleNode("//a:pPr/@lvl",xmlnsManager);
            if (lvlNode != null)
            {
                lvl = int.Parse(lvlNode.Value);
            }
            var buCharNode = nodeXml.SelectSingleNode("//a:pPr/a:buChar/@char",xmlnsManager);
            if (buCharNode != null)
            {
                XmlNode buFontNode = nodeXml.SelectSingleNode("//a:pPr/a:buFont",xmlnsManager);
                if (buFontNode != null)
                {
                    var marginLeft = 328600 * 96 / 914400 * lvl;
                    var marginRight = 0;
                    var typeface = "";
                    XmlNode marLNode = nodeXml.SelectSingleNode("//a:pPr/@marL",xmlnsManager);
                    if (marLNode != null)
                    {
                        marginLeft = int.Parse(marLNode.Value) * 96 / 914400;
                    }
                    XmlNode pitchFamilyNode = nodeXml.SelectSingleNode("//a:pPr/a:buFont/@pitchFamily",xmlnsManager);
                    if (pitchFamilyNode != null)
                    {
                        marginRight = int.Parse(pitchFamilyNode.Value);
                    }
                    XmlNode typefaceNode = nodeXml.SelectSingleNode("//a:pPr/a:buFont/@typeface",xmlnsManager);
                    if (typefaceNode != null)
                    {
                        typeface = typefaceNode.Value;
                    }
                    bchar = new BuChar { MarginLeft = marginLeft, MarginRiht = marginRight, Typeface = typeface, Buchar = buCharNode.Value };
                }
                else
                {
                    int marginLeft = 328600 * 96 / 914400 * lvl;
                    int marginRight = 0;
                    bchar = new BuChar { MarginLeft = marginLeft, MarginRiht = marginRight, Typeface = "", Buchar = buCharNode.Value };
                }
            }
            else
            {
                int marginLeft = 328600 * 96 / 914400 * lvl;
                int marginRight = 0;
                bchar = new BuChar { MarginLeft = marginLeft, MarginRiht = marginRight, Typeface = "", Buchar = "" };
            }
            if (string.IsNullOrEmpty(bchar.Buchar) && typeNode != null && typeNode.Value.Equals("body"))
            {
                string bucharPath = "//p:bodyStyle/a:lvl" + (lvl + 1) + "pPr/a:buChar/@char";
                XmlNode buchar = SlideMasterTextStyles.SelectSingleNode(bucharPath,xmlnsManager);
                if (buchar != null)
                {
                    bchar.Buchar = buchar.Value;

                }
            }
            if (string.IsNullOrEmpty(bchar.Typeface) && typeNode != null && typeNode.Value.Equals("body"))
            {
                string facePath = "//p:bodyStyle/a:lvl" + (lvl + 1) + "pPr/a:buFont/@typeface";
                XmlNode face = SlideMasterTextStyles.SelectSingleNode(facePath,xmlnsManager);

                if (face != null)
                {
                    bchar.Typeface = face.Value;
                }
            }

            if (bchar.FontSize == 0 && typeNode != null && (typeNode.Value.Equals("body") || typeNode.Value.Equals("sldNum")))
            {
                string sizePath = "//p:bodyStyle/a:lvl" + (lvl + 1) + "pPr/a:defRPr/@sz";
                XmlNode size = SlideMasterTextStyles.SelectSingleNode(sizePath,xmlnsManager);

                if (sizePath != null)
                {
                    bchar.FontSize = int.Parse(size.Value) / 100;

                }
            }

            if (hasBuChar)
            {
                string sizePath = "//p:bodyStyle/a:lvl" + (lvl + 1) + "pPr/a:defRPr/@sz";
                XmlNode size = SlideMasterTextStyles.SelectSingleNode(sizePath,xmlnsManager);

                if (sizePath != null)
                {
                    bchar.FontSize = int.Parse(size.Value) / 100;

                }
                string facePath = "//p:bodyStyle/a:lvl" + (lvl + 1) + "pPr/a:buFont/@typeface";
                XmlNode face = SlideMasterTextStyles.SelectSingleNode(facePath,xmlnsManager);

                if (face != null)
                {
                    bchar.Typeface = face.Value;
                }
                string bucharPath = "//p:bodyStyle/a:lvl" + (lvl + 1) + "pPr/a:buChar/@char";
                XmlNode buchar = SlideMasterTextStyles.SelectSingleNode(bucharPath,xmlnsManager);
                if (buchar != null)
                {
                    bchar.Buchar = buchar.Value;

                }
            }
            if (string.IsNullOrEmpty(bchar.Buchar))
            {
                return null;
            }
            return bchar;
        }

        /// <summary>
        /// 获取垂直排版
        /// </summary>
        /// <param name="element"></param>
        /// <param name="slideLayoutSpNode"></param>
        /// <param name="slideMasterSpNode"></param>
        /// <param name="typeNode"></param>
        /// <param name="slideMasterStyle"></param>
        /// <returns></returns>
        public static string GetHorizontalAlign(XmlDocument nodeXml,
            XmlDocument slideLayoutSpNode, XmlDocument slideMasterSpNode,
            XmlNode typeNode, XmlDocument slideMasterTextStyles)
        {
            //XmlDocument doc = new XmlDocument();
            //doc.LoadXml(nodeXml);
            XmlNode algn = nodeXml.SelectSingleNode("//a:pPr/@algn",xmlnsManager);
            if (algn == null)
            {
                if (slideLayoutSpNode != null)
                {
                    algn = slideLayoutSpNode.SelectSingleNode("//p:txBody/a:p/a:pPr/@algn", xmlnsManager);
                }

                if (algn == null && slideMasterSpNode != null)
                {
                    algn = slideMasterSpNode.SelectSingleNode("//p:txBody/a:p/a:pPr/@algn",xmlnsManager);
                }
                if (algn == null && typeNode != null)
                {
                    switch (typeNode.Value)
                    {
                        case "title":
                        case "subTitle":
                        case "ctrTitle":
                            //doc.LoadXml(slideMasterStyle.TypeTable.OuterXml);
                            algn = slideMasterTextStyles.SelectSingleNode("//p:titleStyle/a:lvl1pPr/@algn",xmlnsManager);
                            break;
                        case "body":
                            algn = slideMasterTextStyles.SelectSingleNode("//p:bodyStyle/a:lvl1pPr/@algn",xmlnsManager);
                            break;
                        default:
                            //  doc.LoadXml(slideMasterStyle.TypeTable.OuterXml);
                            algn = slideMasterTextStyles.SelectSingleNode("//p:otherStyle/a:lvl1pPr/@algn",xmlnsManager);
                            break;
                    }
                }
            }
            if (algn == null)
            {
                if (typeNode == null)
                {
                    return "h-left";
                }
                if (typeNode.Value.Equals("title") || typeNode.Value.Equals("subTitle") || typeNode.Value.Equals("ctrTitle"))
                {
                    return "h-mid";
                }
                else if (typeNode.Value == "sldNum")
                {
                    return "h-right";
                }
                else if (typeNode.Value.Equals("body")) { return "h-left"; }
            }
            return algn.Value.Equals("ctr") ? "h-mid" : algn.Value.Equals("r") ? "h-right" : "h-left";
        }


        /// <summary>
        /// 获取水平排版
        /// 上中下对齐 X, <a:bodyPr anchor="ctr">, <a:bodyPr anchor="b">
        /// </summary>
        /// <param name="element"></param>
        /// <param name="slideLayoutSpNode"></param>
        /// <param name="slideMasterSpNode"></param>
        /// <param name="typeNode"></param>
        public static string GetVerticalAlign(string xmlNode,
            XmlDocument slideLayoutSpNode, XmlDocument slideMasterSpNode,
            XmlNode typeNode, XmlDocument slideMasterTextStyles)
        {
            XmlDocument doc = new XmlDocument();
            doc.LoadXml(xmlNode);

            XmlNode anchor = doc.SelectSingleNode("//p:txBody/a:bodyPr/@anchor", xmlnsManager);
            if (anchor == null)
            {
                if (slideLayoutSpNode != null)
                {
                    anchor = slideLayoutSpNode.SelectSingleNode("//p:txBody/a:bodyPr/@anchor", xmlnsManager);
                }
                if (anchor == null && slideMasterSpNode != null)
                {
                    anchor = slideMasterSpNode.SelectSingleNode("//p:txBody/a:bodyPr/@anchor",xmlnsManager);
                }
            }
            if (anchor != null)
            {
                return anchor.Value.Equals("ctr") ? "v-mid" : anchor.Value.Equals("b") ? "v-down" : "v-up";
            }
            else
            {
                return "v-up";
            }

        }

        /// <summary>
        /// 获取位置信息
        /// </summary>
        /// <param name="transform2D"></param>
        /// <returns></returns>
        public static HiTeachCC.Model.PowerPoint.Position GetPositionByTransform2D(Transform2D transform2D)
        {
            HiTeachCC.Model.PowerPoint.Position spPosition = new HiTeachCC.Model.PowerPoint.Position();
            spPosition.Rot = transform2D.Rotation == null ? 0 : transform2D.Rotation.Value;
            spPosition.FlipH = transform2D.HorizontalFlip == null ? 0 : transform2D.HorizontalFlip.Value == true ? 1 : 0;
            spPosition.FlipV = transform2D.VerticalFlip == null ? 0 : transform2D.VerticalFlip.Value == true ? 1 : 0;
            spPosition.X = transform2D.Offset.X == null ? 0 : transform2D.Offset.X.Value;
            spPosition.Y = transform2D.Offset.Y == null ? 0 : transform2D.Offset.Y.Value;
            spPosition.Cx = transform2D.Extents.Cx == null ? 0 : transform2D.Extents.Cx.Value;
            spPosition.Cy = transform2D.Extents.Cy == null ? 0 : transform2D.Extents.Cy.Value;
            return spPosition;
        }


        public static XmlDocument GetSlideMasterTextStyles(string xml)
        {
            XmlDocument doc = new XmlDocument();
            doc.LoadXml(xml);
            XmlNode txStyles = doc.SelectSingleNode("//p:txStyles", xmlnsManager);
            doc.LoadXml(txStyles.OuterXml);
            return doc;
        }

        /// <summary>
        /// 根据slideLayout 或 slideMaster 获取 id idx type
        /// </summary>
        /// <param name="xml"></param>
        /// <returns></returns>
        public static HiTeachCC.Model.PowerPoint.Style IndexNodes(string xml)
        {
            XmlDocument doc = new XmlDocument();
            doc.LoadXml(xml);
            XmlNodeList spTreeNodes = doc.SelectNodes("//p:cSld/p:spTree/child::*", xmlnsManager);

            XmlDocument idTable = new XmlDocument();
            //添加根节点
            XmlElement idElement = idTable.CreateElement("xmlDatas");
            idTable.AppendChild(idElement);

            XmlDocument idxTable = new XmlDocument();
            //添加根节点
            XmlElement idxElement = idxTable.CreateElement("xmlDatas");
            idxTable.AppendChild(idxElement);

            XmlDocument typeTable = new XmlDocument();
            //添加根节点
            XmlElement typeElement = typeTable.CreateElement("xmlDatas");
            typeTable.AppendChild(typeElement);

            if (spTreeNodes != null)
            {
                int size = spTreeNodes.Count;
                for (int i = 0; i < size; i++)
                {
                    XmlNode spnode = spTreeNodes.Item(i);
                    if (spnode.Name.Equals("p:nvGrpSpPr") || spnode.Name.Equals("p:grpSpPr"))
                    {
                        continue;
                    }
                    if (spnode.LocalName.Equals("nvGrpSpPr") || spnode.LocalName.Equals("grpSpPr"))
                    {
                        continue;
                    }
                    XmlDocument docNode = new XmlDocument();
                    docNode.LoadXml(spnode.OuterXml);
                    XmlNode id = spnode.SelectSingleNode("./p:nvSpPr/p:cNvPr/@id", xmlnsManager);
                    XmlNode idx = spnode.SelectSingleNode("./p:nvSpPr/p:nvPr/p:ph/@idx", xmlnsManager);
                    XmlNode type = spnode.SelectSingleNode("./p:nvSpPr/p:nvPr/p:ph/@type", xmlnsManager);

                    var cnode = spnode.ChildNodes;
                    StringBuilder builder = new StringBuilder();
                    for (int m = 0; m < cnode.Count; m++)
                    {
                        var cn = cnode.Item(m);
                        builder.Append(cn.OuterXml);
                    }

                    if (id != null)
                    {
                        XmlDocument docx = new XmlDocument();
                        string str = "<xmlData id=\"" + id.Value + "\">" + builder.ToString() + "</xmlData>";
                        docx.LoadXml(str);
                        //XmlDocument idXmlNode = new XmlDocument();
                        //idXmlNode.LoadXml(idElement.OuterXml);
                        XmlNode importNode = idElement.OwnerDocument.ImportNode(docx.DocumentElement, true);
                        idElement.AppendChild(importNode);

                    }
                    if (idx != null)
                    {
                        XmlDocument docx = new XmlDocument();
                        string str = "<xmlData id=\"" + idx.Value + "\">" + builder.ToString() + "</xmlData>";
                        docx.LoadXml(str);
                        //XmlDocument idxXmlNode = new XmlDocument();
                        //idxXmlNode.LoadXml(idElement.OuterXml);
                        XmlNode importNode = idxElement.OwnerDocument.ImportNode(docx.DocumentElement, true);
                        idxElement.AppendChild(importNode);
                    }
                    if (type != null)
                    {
                        XmlDocument docx = new XmlDocument();
                        string str = "<xmlData id=\"" + type.Value + "\">" + builder.ToString() + "</xmlData>";
                        docx.LoadXml(str);
                        //XmlDocument typeXmlNode = new XmlDocument();
                        //typeXmlNode.LoadXml(idElement.OuterXml);
                        XmlNode importNode = typeElement.OwnerDocument.ImportNode(docx.DocumentElement, true);
                        typeElement.AppendChild(importNode);
                    }
                }
            }
            return new HiTeachCC.Model.PowerPoint.Style { IdTable = idTable, IdxTable = idxTable, TypeTable = typeTable };
        }

        public static Model.PowerPoint.Fill GetSlideBackgroundFill(SlidePart slidePart, SlideMaster slideMaster, Dictionary<string, string> colors, Theme theme)
        {
            Model.PowerPoint.Fill fill = null ;
            XmlDocument doc = new XmlDocument();
            string SlideXml = slidePart.Slide.OuterXml;
            doc.LoadXml(SlideXml);
            /*
             *  blipFill （图片填充）BlipFill
                effectDag （效果容器）EffectDag
                effectLst （效果容器）EffectList
                extLst （扩展名列表）ExtensionList
                gradFill （渐变填充）GradientFill
                grpFill （组填充）
                noFill （无填充）NoFill
                pattFill （图案填充）PatternFill
                compositeElementFill （纯色填充）SolidFill

            phClr 颜色占位
            块引用 该方案颜色值设置为占位符颜色（该值phClr）。
            此值显示在填充，线条，效果和背景样式中，并指示这些设置应用于适用于给定样式的主题颜色。
            这允许相同的填充，线条和效果样式填充OfficeArt图库中显示的主题颜色。
            http://msdn.microsoft.com/en-us/library/cc964302(v=office.12).aspx
             */
            //使用xPath选择需要的节点
            XmlNode node_sld = doc.SelectSingleNode("//p:sld/p:cSld/p:bg/p:bgPr/a:solidFill", xmlnsManager);
            if (node_sld != null)
            {
                SolidFill compositeElement = new SolidFill(node_sld.OuterXml);
                string colorHex = GetBgFill(colors,
                    compositeElement.RgbColorModelPercentage,
                    compositeElement.RgbColorModelHex,
                    compositeElement.HslColor,
                    compositeElement.SystemColor,
                    compositeElement.SchemeColor,
                    compositeElement.PresetColor);
                new Model.PowerPoint.Fill { Type=1,Color=colorHex};
                return fill;
            }
           
            node_sld = doc.SelectSingleNode("//p:sld/p:cSld/p:bg/p:bgPr/a:blipFill", xmlnsManager);
            if (node_sld != null)
            {
                DocumentFormat.OpenXml.Drawing.BlipFill blipFill = new DocumentFormat.OpenXml.Drawing.BlipFill(node_sld.OuterXml);
                var imageRid = blipFill.Blip.Embed.Value;
                IdPartPair idParie = slidePart.Parts.Where(x => x.RelationshipId == imageRid).FirstOrDefault();
                ImagePart imagePart = (ImagePart)idParie.OpenXmlPart;
                var contentType = imagePart.ContentType;
                string base64 = "";
                using (var stream = imagePart.GetStream())
                {
                    byte[] buffer = new byte[stream.Length];
                    stream.Read(buffer, 0, buffer.Length);
                    stream.Close();
                    base64 = System.Convert.ToBase64String(buffer);
                    base64 = "data:" + contentType + ";base64," + base64;
                }
                string a = node_sld.OuterXml;
                doc.LoadXml(slideMaster.OuterXml);
                FillStyle fillStyle = GetFillStyle(doc);
                fill = new Model.PowerPoint.Fill { Type = 3, Image = base64, FillStyle = fillStyle };
                return fill;
            }
            string SlideLayoutXml = slidePart.SlideLayoutPart.SlideLayout.OuterXml;
            OverrideColorMapping colorMap = slidePart.SlideLayoutPart.SlideLayout.ColorMapOverride.OverrideColorMapping;
            Dictionary<string, string> styleColors = new Dictionary<string, string>();
            if (colorMap != null)
            {
                styleColors = DoColorMap(colorMap, null, theme);
            }
            else
            {
                styleColors = colors;
            }
            doc.LoadXml(SlideLayoutXml);
            XmlNode node_sldLayout = doc.SelectSingleNode("//p:sldLayout/p:cSld/p:bg/p:bgPr/a:solidFill", xmlnsManager);
            if (node_sldLayout != null)
            {
                SolidFill compositeElement = new SolidFill(node_sldLayout.OuterXml);
                string colorHex = GetBgFill(styleColors,
                    compositeElement.RgbColorModelPercentage,
                    compositeElement.RgbColorModelHex,
                    compositeElement.HslColor,
                    compositeElement.SystemColor,
                    compositeElement.SchemeColor,
                    compositeElement.PresetColor);
                new Model.PowerPoint.Fill { Type = 1, Color = colorHex };
                return fill;
            }
            node_sldLayout = doc.SelectSingleNode("//p:sldLayout/p:cSld/p:bg/p:bgRef", xmlnsManager);
            if (node_sldLayout != null)
            {
                BackgroundStyleReference compositeElement = new BackgroundStyleReference(node_sldLayout.OuterXml);

                string colorHex = GetBgFill(styleColors, compositeElement.RgbColorModelPercentage,
                    compositeElement.RgbColorModelHex,
                    compositeElement.HslColor,
                    compositeElement.SystemColor,
                    compositeElement.SchemeColor,
                    compositeElement.PresetColor);
                new Model.PowerPoint.Fill { Type = 1, Color = colorHex };
                return fill;
            }
            string slideMasterXml = slideMaster.OuterXml;
            doc.LoadXml(slideMasterXml);
            XmlNode node_sldMaster = doc.SelectSingleNode("//p:sldMaster/p:cSld/p:bg/p:bgPr/a:solidFill", xmlnsManager);
            if (node_sldMaster != null)
            {
                SolidFill compositeElement = new SolidFill(node_sldMaster.OuterXml);
                string colorHex = GetBgFill(colors, compositeElement.RgbColorModelPercentage,
                    compositeElement.RgbColorModelHex,
                    compositeElement.HslColor,
                    compositeElement.SystemColor,
                    compositeElement.SchemeColor,
                    compositeElement.PresetColor);
                new Model.PowerPoint.Fill { Type = 1, Color = colorHex };
                return fill;
            }
            node_sldMaster = doc.SelectSingleNode("//p:sldMaster/p:cSld/p:bg/p:bgRef", xmlnsManager);
            if (node_sldMaster != null)
            {
                BackgroundStyleReference compositeElement = new BackgroundStyleReference(node_sldMaster.OuterXml);
                string colorHex = GetBgFill(colors, compositeElement.RgbColorModelPercentage,
                    compositeElement.RgbColorModelHex,
                    compositeElement.HslColor,
                    compositeElement.SystemColor,
                    compositeElement.SchemeColor,
                    compositeElement.PresetColor);
                new Model.PowerPoint.Fill { Type = 1, Color = colorHex };
                return fill;
            }
            doc.LoadXml(slideMaster.OuterXml);
            node_sld = doc.SelectSingleNode("//p:sldMaster/p:cSld/p:bg/p:bgPr/a:blipFill", xmlnsManager);
            if (node_sld != null)
            {
              
                var imgpart = slideMaster.SlideMasterPart.ImageParts;
                if (imgpart != null)
                {
                    string bg64 = "";
                    imgpart.ToList().ForEach(yy =>
                    {
                        var bgct = yy.ContentType;
                        using (var stream = yy.GetStream())
                        {
                            byte[] buffer = new byte[stream.Length];
                            stream.Read(buffer, 0, buffer.Length);
                            stream.Close();
                            bg64 = System.Convert.ToBase64String(buffer);
                            bg64 = "data:" + bgct + ";base64," + bg64;
                        }
                    });
                    string a =  node_sld.OuterXml;
                    doc.LoadXml(slideMaster.OuterXml);
                    FillStyle fillStyle = GetFillStyle( doc);
                    fill = new Model.PowerPoint.Fill { Type = 3, Image = bg64, FillStyle = fillStyle };
                    return fill;
                }
            }
            //if (fill == null) {

            //}

            return null ;
        }

        private static FillStyle GetFillStyle(XmlDocument doc)
        {
            XmlNode fillRect_node = doc.SelectSingleNode("//a:stretch/a:fillRect", xmlnsManager);
            FillStyle fillStyle = new FillStyle();
            if (fillRect_node != null)
            {
                XmlNode left = doc.SelectSingleNode("//a:stretch/a:fillRect/@l", xmlnsManager);
                XmlNode top = doc.SelectSingleNode("//a:stretch/a:fillRect/@t", xmlnsManager);
                XmlNode right = doc.SelectSingleNode("//a:stretch/a:fillRect/@r", xmlnsManager);
                XmlNode bottom = doc.SelectSingleNode("//a:stretch/a:fillRect/@b", xmlnsManager);
                if (left != null)
                {
                    fillStyle.Left = int.Parse(left.Value);
                }
                if (top != null)
                {
                    fillStyle.Top = int.Parse(top.Value);
                }
                if (right != null)
                {
                    fillStyle.Right = int.Parse(right.Value);
                }
                if (bottom != null)
                {
                    fillStyle.Bottom = int.Parse(bottom.Value);
                }
            }

            return fillStyle;
        }

        public static Dictionary<string, string> DoColorMap(OverrideColorMapping overrideColorMapping, ColorMap colorMap, Theme theme)
        {
            string[] colors = { "accent1", "accent2", "accent3", "accent4", "accent5", "accent6",
                                "lt1", "lt2", "tx1", "tx2", "dk1","dk2","hlink","folHlink","bg1","bg2" };
            DocumentFormat.OpenXml.Drawing.ColorScheme colorScheme = theme.ThemeElements.ColorScheme;
            Dictionary<string, string> pairs = new Dictionary<string, string>();
            Dictionary<string, string> colorDict = new Dictionary<string, string>();
            if (overrideColorMapping != null)
            {
                colorDict.Add("Text1", overrideColorMapping.Text1);
                colorDict.Add("Text2", overrideColorMapping.Text2);
                colorDict.Add("Background1", overrideColorMapping.Background1);
                colorDict.Add("Background2", overrideColorMapping.Background2);
            }
            else
            {
                if (colorMap != null)
                {
                    colorDict.Add("Text1", colorMap.Text1);
                    colorDict.Add("Text2", colorMap.Text2);
                    colorDict.Add("Background1", colorMap.Background1);
                    colorDict.Add("Background2", colorMap.Background2);
                }
            }
            foreach (var col in colors)
            {
                pairs.Add(col, PowerPointHelper.ColorForThemeClr(col, colorScheme, colorDict));
            }
            return pairs;
        }
        private static string GetBgFill(Dictionary<string, string> colors,
            RgbColorModelPercentage RgbColorModelPercentage,
            RgbColorModelHex RgbColorModelHex,
            DocumentFormat.OpenXml.Drawing.HslColor HslColor,
            SystemColor SystemColor,
            SchemeColor SchemeColor,
            PresetColor PresetColor)
        {
            var colorHex = "#FFF";


            if (RgbColorModelPercentage != null)
            {
                int r = RgbColorModelPercentage.RedPortion.Value;
                int g = RgbColorModelPercentage.GreenPortion.Value;
                int b = RgbColorModelPercentage.BluePortion.Value;
                colorHex = "#" + ColorTranslator.ToHtml(Color.FromArgb(r, g, b));
            }
            if (RgbColorModelHex != null)
            {
                colorHex = "#" + RgbColorModelHex.Val;
            }
            if (HslColor != null)
            {
                ColorHSL colorHSL = new ColorHSL { H = HslColor.HueValue.Value, S = HslColor.SatValue.Value, L = HslColor.LumValue.Value };
                ColorRGB rbg = ColorHelper.HslToRgb(colorHSL);
                colorHex = "#" + ColorTranslator.ToHtml(Color.FromArgb(rbg.R, rbg.G, rbg.B));
            }
            if (SystemColor != null)
            {
                if (colors.TryGetValue(SystemColor.Val, out string clr))
                {
                    colorHex = "#" + clr;
                }
            }
            if (SchemeColor != null)
            {
                if (colors.TryGetValue(SchemeColor.Val, out string clr))
                {
                    colorHex = "#" + clr;
                    if (SchemeColor.ChildElements != null && SchemeColor.ChildElements.Count > 0)
                    {
                        colorHex = "#" + ColorToning(SchemeColor.OuterXml, colorHex.Replace("#", ""));

                    }
                }
            }
            if (PresetColor != null)
            {
                colorHex = PresetColor.Val.ToString().Replace("2010", "");
                System.Drawing.Color color = System.Drawing.Color.FromName(colorHex);
                colorHex = ColorTranslator.ToHtml(color);
            }
            return colorHex;
        }


        /// <summary>
        /// 在主题Theme中获取颜色
        /// </summary>
        /// <param name="scv"></param>
        /// <param name="theme"></param>
        /// <returns></returns>
        public static string ColorForThemeClr(string scv, DocumentFormat.OpenXml.Drawing.ColorScheme colorScheme, Dictionary<string, string> colorMap)
        {
            string colorStr = "";
            if (scv.Equals("tx1"))
            {
                if (colorMap.TryGetValue("Text1", out string Text1))
                    colorStr = ColorForThemeClr(Text1, colorScheme, colorMap);
                return colorStr;
            }
            else if (scv.Equals("bg1"))
            {
                if (colorMap.TryGetValue("Background1", out string Background1))
                    colorStr = ColorForThemeClr(Background1, colorScheme, colorMap);
                return colorStr;
            }
            else if (scv.Equals("bg2"))
            {
                if (colorMap.TryGetValue("Background2", out string Background2))
                    colorStr = ColorForThemeClr(Background2, colorScheme, colorMap);
                return colorStr;
            }
            else if (scv.Equals("tx2"))
            {
                if (colorMap.TryGetValue("Text2", out string Text2))
                    colorStr = ColorForThemeClr(Text2, colorScheme, colorMap);
                return colorStr;
            }
            else if (scv.Equals("dk1"))
            {
                DocumentFormat.OpenXml.Drawing.SystemColor sysColor = colorScheme.Dark1Color.ChildElements.First<DocumentFormat.OpenXml.Drawing.SystemColor>();
                if (sysColor != null)
                {
                    return sysColor.LastColor;
                }
                DocumentFormat.OpenXml.Drawing.RgbColorModelHex rgbColor = colorScheme.Dark1Color.ChildElements.First<DocumentFormat.OpenXml.Drawing.RgbColorModelHex>();
                if (rgbColor != null)
                {
                    return rgbColor.Val;
                }
                return colorStr;
            }
            else if (scv.Equals("dk2"))
            {
                DocumentFormat.OpenXml.Drawing.SystemColor sysColor = colorScheme.Dark2Color.ChildElements.First<DocumentFormat.OpenXml.Drawing.SystemColor>();
                if (sysColor != null)
                {
                    return sysColor.LastColor;
                }
                DocumentFormat.OpenXml.Drawing.RgbColorModelHex rgbColor = colorScheme.Dark2Color.ChildElements.First<DocumentFormat.OpenXml.Drawing.RgbColorModelHex>();
                if (rgbColor != null)
                {
                    return rgbColor.Val;
                }
                return colorStr;
            }
            else if (scv.Equals("accent1"))
            {
                DocumentFormat.OpenXml.Drawing.SystemColor sysColor = colorScheme.Accent1Color.ChildElements.First<DocumentFormat.OpenXml.Drawing.SystemColor>();
                if (sysColor != null)
                {
                    return sysColor.LastColor;
                }
                DocumentFormat.OpenXml.Drawing.RgbColorModelHex rgbColor = colorScheme.Accent1Color.ChildElements.First<DocumentFormat.OpenXml.Drawing.RgbColorModelHex>();
                if (rgbColor != null)
                {
                    return rgbColor.Val;
                }
                return colorStr;
            }
            else if (scv.Equals("accent2"))
            {
                DocumentFormat.OpenXml.Drawing.SystemColor sysColor = colorScheme.Accent2Color.ChildElements.First<DocumentFormat.OpenXml.Drawing.SystemColor>();
                if (sysColor != null)
                {
                    return sysColor.LastColor;
                }
                DocumentFormat.OpenXml.Drawing.RgbColorModelHex rgbColor = colorScheme.Accent2Color.ChildElements.First<DocumentFormat.OpenXml.Drawing.RgbColorModelHex>();
                if (rgbColor != null)
                {
                    return rgbColor.Val;
                }
                return colorStr;
            }
            else if (scv.Equals("accent3"))
            {
                DocumentFormat.OpenXml.Drawing.SystemColor sysColor = colorScheme.Accent3Color.ChildElements.First<DocumentFormat.OpenXml.Drawing.SystemColor>();
                if (sysColor != null)
                {
                    return sysColor.LastColor;
                }
                DocumentFormat.OpenXml.Drawing.RgbColorModelHex rgbColor = colorScheme.Accent3Color.ChildElements.First<DocumentFormat.OpenXml.Drawing.RgbColorModelHex>();
                if (rgbColor != null)
                {
                    return rgbColor.Val;
                }
                return colorStr;
            }
            else if (scv.Equals("accent4"))
            {
                DocumentFormat.OpenXml.Drawing.SystemColor sysColor = colorScheme.Accent4Color.ChildElements.First<DocumentFormat.OpenXml.Drawing.SystemColor>();
                if (sysColor != null)
                {
                    return sysColor.LastColor;
                }
                DocumentFormat.OpenXml.Drawing.RgbColorModelHex rgbColor = colorScheme.Accent4Color.ChildElements.First<DocumentFormat.OpenXml.Drawing.RgbColorModelHex>();
                if (rgbColor != null)
                {
                    return rgbColor.Val;
                }
                return colorStr;
            }
            else if (scv.Equals("accent5"))
            {
                DocumentFormat.OpenXml.Drawing.SystemColor sysColor = colorScheme.Accent5Color.ChildElements.First<DocumentFormat.OpenXml.Drawing.SystemColor>();
                if (sysColor != null)
                {
                    return sysColor.LastColor;
                }
                DocumentFormat.OpenXml.Drawing.RgbColorModelHex rgbColor = colorScheme.Accent5Color.ChildElements.First<DocumentFormat.OpenXml.Drawing.RgbColorModelHex>();
                if (rgbColor != null)
                {
                    return rgbColor.Val;
                }
                return colorStr;
            }
            else if (scv.Equals("accent6"))
            {
                DocumentFormat.OpenXml.Drawing.SystemColor sysColor = colorScheme.Accent6Color.ChildElements.First<DocumentFormat.OpenXml.Drawing.SystemColor>();
                if (sysColor != null)
                {
                    return sysColor.LastColor;
                }
                DocumentFormat.OpenXml.Drawing.RgbColorModelHex rgbColor = colorScheme.Accent6Color.ChildElements.First<DocumentFormat.OpenXml.Drawing.RgbColorModelHex>();
                if (rgbColor != null)
                {
                    return rgbColor.Val;
                }
                return colorStr;
            }
            else if (scv.Equals("lt1"))
            {
                DocumentFormat.OpenXml.Drawing.SystemColor sysColor = colorScheme.Light1Color.ChildElements.First<DocumentFormat.OpenXml.Drawing.SystemColor>();
                if (sysColor != null)
                {
                    return sysColor.LastColor;
                }
                DocumentFormat.OpenXml.Drawing.RgbColorModelHex rgbColor = colorScheme.Light1Color.ChildElements.First<DocumentFormat.OpenXml.Drawing.RgbColorModelHex>();
                if (rgbColor != null)
                {
                    return rgbColor.Val;
                }
                return colorStr;
            }
            else if (scv.Equals("lt2"))
            {
                DocumentFormat.OpenXml.Drawing.SystemColor sysColor = colorScheme.Light2Color.ChildElements.First<DocumentFormat.OpenXml.Drawing.SystemColor>();
                if (sysColor != null)
                {
                    return sysColor.LastColor;
                }
                DocumentFormat.OpenXml.Drawing.RgbColorModelHex rgbColor = colorScheme.Light2Color.ChildElements.First<DocumentFormat.OpenXml.Drawing.RgbColorModelHex>();
                if (rgbColor != null)
                {
                    return rgbColor.Val;
                }
                return colorStr;
            }
            else if (scv.Equals("hlink"))
            {
                DocumentFormat.OpenXml.Drawing.SystemColor sysColor = colorScheme.Hyperlink.ChildElements.First<DocumentFormat.OpenXml.Drawing.SystemColor>();
                if (sysColor != null)
                {
                    return sysColor.LastColor;
                }
                DocumentFormat.OpenXml.Drawing.RgbColorModelHex rgbColor = colorScheme.Hyperlink.ChildElements.First<DocumentFormat.OpenXml.Drawing.RgbColorModelHex>();
                if (rgbColor != null)
                {
                    return rgbColor.Val;
                }
                return colorStr;
            }
            else if (scv.Equals("folHlink"))
            {
                DocumentFormat.OpenXml.Drawing.SystemColor sysColor = colorScheme.FollowedHyperlinkColor.ChildElements.First<DocumentFormat.OpenXml.Drawing.SystemColor>();
                if (sysColor != null)
                {
                    return sysColor.LastColor;
                }
                DocumentFormat.OpenXml.Drawing.RgbColorModelHex rgbColor = colorScheme.FollowedHyperlinkColor.ChildElements.First<DocumentFormat.OpenXml.Drawing.RgbColorModelHex>();
                if (rgbColor != null)
                {
                    return rgbColor.Val;
                }
                return colorStr;
            }
            return colorStr;
        }
    }
}