ASP.NET基于Aspose.Words插入Word水印以及多个水印

using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
using System.Data;
using Aspose.Words;
using System.Configuration;
using System.Data.SqlClient;
using System.Reflection;
using Aspose.Words.Drawing;
using System.Text.RegularExpressions;
using System.IO;
using Aspose.Words.Saving;
using Aspose.Words.Tables;
using System.Text;
using System.Drawing.Printing;
using System.Collections;
 
namespace WebControl
{
    public class Print
    {
        private void SaveDocument(Document doc)
        {
            //SaveOptions saveop = SaveOptions.CreateSaveOptions(filename + ".doc");
            //doc.Save(HttpContext.Current.Response, filename + ".doc", ContentDisposition.Attachment, saveop);
            if (Dotype.Equals("word"))
            {
                SaveOptions saveop = SaveOptions.CreateSaveOptions(filename + ".doc");
                doc.Save(HttpContext.Current.Response, filename + ".doc", ContentDisposition.Attachment, saveop);
            }
            else if (Dotype.Equals("pdf"))
            {
 
                filename = filename + ".pdf";
                string dirpath = HttpContext.Current.Server.MapPath("~/FlexPaper/docs");
                if (!Directory.Exists(dirpath))
                {
                    Directory.CreateDirectory(dirpath);
                }
                string strpath = dirpath + "/" + filename;
                if (File.Exists(strpath))
                {
                    File.Delete(strpath);
                }
                doc.Save(strpath, SaveFormat.Pdf);
                FileInfo fileInfo = new FileInfo(strpath);
                HttpContext.Current.Response.Clear();
                HttpContext.Current.Response.ClearContent();
                HttpContext.Current.Response.ClearHeaders();
                filename = System.Web.HttpUtility.UrlEncode(filename, System.Text.Encoding.UTF8);
                HttpContext.Current.Response.AddHeader("Content-Disposition", "attachment;filename=" + filename);
                HttpContext.Current.Response.AddHeader("Content-Length", fileInfo.Length.ToString());
                HttpContext.Current.Response.AddHeader("Content-Transfer-Encoding", "binary");
                HttpContext.Current.Response.ContentType = "application/octet-stream";
                //Response.ContentEncoding = System.Text.Encoding.UTF8;
                HttpContext.Current.Response.WriteFile(fileInfo.FullName);
                HttpContext.Current.Response.Flush();
                HttpContext.Current.Response.End();
            }
 
        }
 
        #region 打印多个模板拼接成word
 
        public Document printDocumentAllWordMore(List<PrintData> datalist)
        {
            int p = ;
            Document maindoc = new Document();
            foreach (var page in datalist)
            {
                Document newdoc = new Document(page.wordpath);
                DocumentBuilder builder = new DocumentBuilder(newdoc);
                List<DataTable> dtinfos = page.dtinfos;
 
                if (dtinfos != null)
                {
                    for (int i = ; i < dtinfos.Count; i++)
                    {
                        DataTable dtinfo = dtinfos[i];
                        if (dtinfo != null)
                        {
                            for (int n = ; n < dtinfo.Columns.Count; n++)
                            {
                                string fieldname = dtinfo.Columns[n].ColumnName.ToLower();
                                try
                                {
                                    string fieldvalue = dtinfo.Rows[][fieldname].ToString();
                                    newdoc.Range.Replace(WordTabChar + fieldname + WordTabChar, fieldvalue, false, false);
                                }
                                catch { }
                            }
                        }
                    }
                }
                Dictionary<string, string> dict = page.dict;
                if (dict != null)
                {
                    foreach (var key in dict.Keys)
                    {
                        try
                        {
                            newdoc.Range.Replace(WordTabChar + key + WordTabChar, dict[key], false, false);
                        }
                        catch { }
                    }
                }
                List<PositionProChildren> listpos = new List<PositionProChildren>();
                List<DataTable> dtlist = page.dtlist;
                int section = newdoc.GetChildNodes(NodeType.Section, true).Count;
                int dataindex = ;
                for (int kk = ; kk < section; kk++)
                {
                    Aspose.Words.Section dtsection = (Aspose.Words.Section)newdoc.GetChild(NodeType.Section, kk, true);
                    int num = dtsection.Body.Tables.Count;
                    for (int mm = ; mm < num; mm++)
                    {
                        Aspose.Words.Tables.Table dtdoc1 = dtsection.Body.Tables[mm];
 
                        for (int r = ; r < dtdoc1.Rows.Count; r++)
                        {
                            for (int c = ; c < dtdoc1.Rows[r].Cells.Count; c++)
                            {
                                if (dtdoc1.Rows[r].Cells[c].Range.Text.ToLower().Contains("#start#"))
                                {
                                    PositionProChildren pos = new PositionProChildren();
                                    pos.tableindex = mm;
                                    pos.row_start = r;
                                    pos.cell_start = c;
                                    pos.row_end = r;
                                    pos.cell_end = c;
                                    listpos.Add(pos);
                                    dtdoc1.Rows[r].Cells[c].Range.Replace("#START#", "", false, false);
                                }
                                if (dtdoc1.Rows[r].Cells[c].Range.Text.ToLower().Contains("#end#"))
                                {
                                    PositionProChildren pos = listpos.Last<PositionProChildren>();
                                    pos.row_end = r;
                                    pos.cell_end = c;
                                    dtdoc1.Rows[r].Cells[c].Range.Replace("#END#", "", false, false);
                                }
                            }
                        }
                        for (int i = ; i < listpos.Count; i++)
                        {
                            PositionProChildren pos = new PositionProChildren();
                            if (listpos.Count > i)
                            {
                                pos = listpos[i];
                            }
                            DataTable dt = dtlist[i + dataindex];
 
                            Aspose.Words.Tables.Table dtdoc = dtsection.Body.Tables[mm];
                            List<string> celltabs = new List<string>();
                            for (int t = pos.cell_start; t < dtdoc.Rows[pos.row_start].Cells.Count; t++)
                            {
                                string colname = dtdoc.Rows[pos.row_start].Cells[t].Range.Text.Replace(WordTabChar, "").Replace("\a", "");
                                celltabs.Add(colname);
                                dtdoc.Rows[pos.row_start].Range.Replace(WordTabChar + colname + WordTabChar, "", false, false);
                            }
                            if (dt.Rows.Count > pos.rownum)
                            {
                                int addrow = dt.Rows.Count - pos.rownum;
                                for (int a = ; a < addrow; a++)
                                {
                                    Aspose.Words.Node newrow = dtdoc.Rows[pos.row_start + ].Clone(true);//确认模板有第二行
 
                                    //Aspose.Words.Node newrow = dtdoc.Rows[pos.row_start].Clone(true);
                                    dtdoc.Rows.Insert(pos.row_start + , newrow);
                                    if (i < listpos.Count - )
                                    {
                                        for (int l = i + ; l < listpos.Count; l++)
                                        {
                                            PositionProChildren poscur = listpos[l - ];
                                            PositionProChildren posnext = listpos[l];
                                            if (posnext.tableindex.Equals(poscur.tableindex))
                                            {
                                                posnext.row_start += ;
                                                posnext.row_end += ;
                                            }
                                            else
                                                break;
                                        }
                                    }
                                }
 
                            }
 
                            for (int m = ; m < dt.Rows.Count; m++)
                            {
                                for (int n = ; n < celltabs.Count; n++)
                                {
                                    try
                                    {
                                        builder.MoveToSection(kk);
                                        //builder.MoveTo(newdoc.Sections[kk].Body.Tables[mm].Rows[pos.row_start + m].Cells[pos.cell_start + n].Paragraphs[0].Runs[0]);
                                        builder.MoveToCell(pos.tableindex, pos.row_start + m, pos.cell_start + n, );
                                        builder.Write(dt.Rows[m][celltabs[n].ToString()].ToString());
                                    }
                                    catch { }
                                }
                            }
 
                        }
 
                        //dataindex = 0;
                        dataindex = dataindex + listpos.Count;
                        listpos.Clear();
 
                    }
 
                }
                if (!p.Equals())
                {
                    newdoc.FirstSection.PageSetup.SectionStart = SectionStart.NewPage;
                    maindoc.AppendDocument(newdoc, ImportFormatMode.KeepSourceFormatting);
                }
                else
                {
                    maindoc = newdoc;
                }
                p++;
            }
            return maindoc;
        }
 
        public void PrintMoreMb(List<List<PrintData>> datalist)
        {
            if (datalist.Count > )
            {
                Document maindoc = printDocumentAllWordMore(datalist[]);
                Document newdoc = new Document();
                for (int i = ; i < datalist.Count; i++)
                {
                    newdoc = printDocumentAllWordMore(datalist[i]);
                    newdoc.FirstSection.PageSetup.SectionStart = SectionStart.NewPage;
                    maindoc.AppendDocument(newdoc, ImportFormatMode.KeepSourceFormatting);
                }
                maindoc.Protect(ProtectionType.AllowOnlyFormFields, "mima");
                WaterMark(maindoc, HttpContext.Current.Session["LRXSMC_SH"].ToString());
                //WaterMarkMore(maindoc, HttpContext.Current.Session["LRXSMC_SH"].ToString());
                this.SaveDocument(maindoc);
            }
 
        }
 
        //public Object apply(Shape watermark)
        //{
        //    watermark.setRelativeHorizontalPosition(RelativeHorizontalPosition.MARGIN);
        //    watermark.setRelativeVerticalPosition(RelativeVerticalPosition.MARGIN);
        //    watermark.setWrapType(WrapType.NONE);
        //    //  我们需要自定义距离顶部的高度
        //    // watermark.setVerticalAlignment(VerticalAlignment.TOP);
        //    watermark.setHorizontalAlignment(HorizontalAlignment.CENTER);
        //    // 设置距离顶部的高度
        //    watermark.setTop(160);
 
        //    return null;
        //}
 
        /// <summary>
        /// 插入多个水印
        /// </summary>
        /// <param name="mdoc">Document</param>
        /// <param name="wmText">水印文字名</param>
        /// <param name="left">左边距多少</param>
        /// <param name="top">上边距多少</param>
        /// <returns></returns>
        public static Shape ShapeMore(Document mdoc, string wmText, double left, double top)
        {
            Shape waterShape = new Shape(mdoc, ShapeType.TextPlainText);
            //设置该文本的水印
            waterShape.TextPath.Text = wmText;
            waterShape.TextPath.FontFamily = "宋体";
            waterShape.Width = ;
            waterShape.Height = ;
            //文本将从左下角到右上角。
            waterShape.Rotation = ;
            //绘制水印颜色
            waterShape.Fill.Color = System.Drawing.Color.Gray;//浅灰色水印
            waterShape.StrokeColor = System.Drawing.Color.Gray;
            //将水印放置在页面中心
            waterShape.Left = left;
            waterShape.Top = top;
            waterShape.WrapType = WrapType.None;
            return waterShape;
        }
 
        /// <summary>
        /// 插入多个水印
        /// </summary>
        /// <param name="mdoc">Document</param>
        /// <param name="wmText">水印文字名</param>
        public static void WaterMarkMore(Document mdoc, string wmText)
        {
            Paragraph watermarkPara = new Paragraph(mdoc);
            for (int j = ; j < ; j = j + )
            {
                for (int i = ; i < ; i = i + )
                {
                    Shape waterShape = ShapeMore(mdoc, wmText, j, i);
                    watermarkPara.AppendChild(waterShape);
                }
            }
 
            // 在每个部分中，最多可以有三个不同的标题，因为我们想要出现在所有页面上的水印，插入到所有标题中。
            foreach (Section sect in mdoc.Sections)
            {
                // 每个区段可能有多达三个不同的标题，因为我们希望所有页面上都有水印，将所有的头插入。
                InsertWatermarkIntoHeader(watermarkPara, sect, HeaderFooterType.HeaderPrimary);
                InsertWatermarkIntoHeader(watermarkPara, sect, HeaderFooterType.HeaderFirst);
                InsertWatermarkIntoHeader(watermarkPara, sect, HeaderFooterType.HeaderEven);
            }
        }
 
        /// <summary>
        /// 插入水印
        /// </summary>
        /// <param name="mdoc">Document</param>
        /// <param name="wmText">水印名称</param>
        public static void WaterMark(Document mdoc, string wmText)
        {
            Shape waterShape = new Shape(mdoc, ShapeType.TextPlainText);
            //设置该文本的水印
            waterShape.TextPath.Text = wmText;
            waterShape.TextPath.FontFamily = "宋体";
            waterShape.Width = ;
            waterShape.Height = ;
            //文本将从左下角到右上角。
            waterShape.Rotation = -;
            //绘制水印颜色
            waterShape.Fill.Color = System.Drawing.Color.Gray;//浅灰色水印
            waterShape.StrokeColor = System.Drawing.Color.Gray;
 
            //waterShape.Fill.Color = System.Drawing.Color.FromName("#DFF1DF");//浅灰色水印
            //waterShape.StrokeColor = System.Drawing.Color.Gray;
 
            //将水印放置在页面中心
            //waterShape.Left = 200;
            //waterShape.Top = 600;
            waterShape.RelativeHorizontalPosition = RelativeHorizontalPosition.Page;
            waterShape.RelativeVerticalPosition = RelativeVerticalPosition.Page;
            waterShape.WrapType = WrapType.None;
            waterShape.VerticalAlignment = VerticalAlignment.Center;
            waterShape.HorizontalAlignment = HorizontalAlignment.Center;
 
            // 创建一个新段落并在该段中添加水印。
            Paragraph watermarkPara = new Paragraph(mdoc);
            watermarkPara.AppendChild(waterShape);
 
            // 在每个部分中，最多可以有三个不同的标题，因为我们想要出现在所有页面上的水印，插入到所有标题中。
            foreach (Section sect in mdoc.Sections)
            {
                // 每个区段可能有多达三个不同的标题，因为我们希望所有页面上都有水印，将所有的头插入。
                InsertWatermarkIntoHeader(watermarkPara, sect, HeaderFooterType.HeaderPrimary);
                InsertWatermarkIntoHeader(watermarkPara, sect, HeaderFooterType.HeaderFirst);
                InsertWatermarkIntoHeader(watermarkPara, sect, HeaderFooterType.HeaderEven);
            }
        }
        private static void InsertWatermarkIntoHeader(Paragraph watermarkPara, Section sect, HeaderFooterType headerType)
        {
            HeaderFooter header = sect.HeadersFooters[headerType];
 
            if (header == null)
            {
                // 当前节中没有指定类型的头，创建它
                header = new HeaderFooter(sect.Document, headerType);
                sect.HeadersFooters.Add(header);
            }
 
            // 在头部插入一个水印的克隆
            header.AppendChild(watermarkPara.Clone(true));
        }
 
        #endregion
 
    }
 
        public class ReplaceText : IReplacingCallback
    {
        /// <summary>
        /// 替换文本格式
        /// </summary>
        public string Text { get; set; }
        public ReplaceText(string Text)
        {
            this.Text = Text;
        }
        public ReplaceAction Replacing(ReplacingArgs e)
        {
            //获取当前节点
            var node = e.MatchNode;
            Document doc = node.Document as Document;
            DocumentBuilder builder = new DocumentBuilder(doc);
            builder.MoveTo(node);
            builder.Write(Text);
            return ReplaceAction.Replace;
        }
    }
 
    public class ReplaceHtml : IReplacingCallback
    {
        /// <summary>
        /// 替换为html格式
        /// </summary>
        public string Text { get; set; }
        public ReplaceHtml(string Text)
        {
            this.Text = Text;
        }
        public ReplaceAction Replacing(ReplacingArgs e)
        {
            //获取当前节点
            var node = e.MatchNode;
            Document doc = node.Document as Document;
            DocumentBuilder builder = new DocumentBuilder(doc);
            builder.MoveTo(node);
            builder.InsertHtml(Text);
            return ReplaceAction.Replace;
        }
    }
 
    public class ReplaceImage : IReplacingCallback
    {
        /// <summary>
        /// 替换图片
        /// </summary>
        public string ImageUrl { get; set; }
        //
        public ReplaceImage(string url)
        {
            this.ImageUrl = url;
        }
        public ReplaceAction Replacing(ReplacingArgs e)
        {
            //获取当前节点
            if (!string.IsNullOrEmpty(ImageUrl))
            {
                var node = e.MatchNode;
                Document doc = node.Document as Document;
                DocumentBuilder builder = new DocumentBuilder(doc);
                builder.MoveTo(node);
                //builder.Write(Text);
                Shape shape = new Shape(doc, ShapeType.Image);
                shape.ImageData.SetImage(ImageUrl);
                shape.Top = ;
                shape.Width = ;
                shape.Height = ;
                shape.HorizontalAlignment = HorizontalAlignment.Center;
                CompositeNode node1 = shape.ParentNode;
                builder.InsertNode(shape);
            }
            return ReplaceAction.Replace;
        }
    }
 
    public class PositionPro
    {
        public string key { get; set; }
        public int row_start { get; set; }
        public int row_end { get; set; }
        public int cell_start { get; set; }
        public int cell_end { get; set; }
        public int rownum
        {
            get
            {
                return row_end - row_start + ;
            }
        }
    }
 
    public class PrintData
    {
        public List<DataTable> dtinfos;
        public Dictionary<string, string> dict;
        public List<DataTable> dtlist;
        public string wordpath;
    }
 
    public class PositionProChildren
    {
        public int tableindex { get; set; }
        public string key { get; set; }
        public int row_start { get; set; }
        public int row_end { get; set; }
        public int cell_start { get; set; }
        public int cell_end { get; set; }
        public int rownum
        {
            get
            {
                return row_end - row_start + ;
            }
        }
    }
}