using System.Collections.Generic;
using System.IO;
using DocumentFormat.OpenXml;
using DocumentFormat.OpenXml.Packaging;
using DocumentFormat.OpenXml.Wordprocessing;
using AA = DocumentFormat.OpenXml.Drawing;
using V = DocumentFormat.OpenXml.Vml;
using DW = DocumentFormat.OpenXml.Drawing.Wordprocessing;
using System.Linq;
using PIC = DocumentFormat.OpenXml.Drawing.Pictures;
using System;
using System.Runtime.InteropServices;
using System.Diagnostics;
using System.Threading;
namespace Wisdombud.Report
{
public static partial class OpenXmlUtil
{
/// <summary>
/// 按书签替换图片
/// </summary>
/// <param name="filePath"></param>
/// <param name="picPath"></param>
/// <param name="bm"></param>
/// <param name="x">宽度厘米</param>
/// <param name="y">高度厘米</param>
/// <param name="type"></param>
public static void ReplaceBMPicture(string filePath, string picPath, string bm)
{
RemoveBookMarkContent(filePath, bm);
InsertBMPicture(filePath, picPath, bm);
}
/// <summary>
/// 修改单元格内容
/// </summary>
/// <param name="cell"></param>
/// <param name="content"></param>
public static void ModifyCell(TableCell cell, string content)
{
Paragraph pa = cell.Elements<Paragraph>().FirstOrDefault();
if (pa == null)
{
pa = new Paragraph();
cell.Append(pa);
}
List<Paragraph> paraList = new List<Paragraph>();
foreach (var inst in cell.Elements<Paragraph>())
{
if (inst == pa)
{
continue;
}
paraList.Add(inst);
}
foreach (var inst in paraList)
{
inst.Remove();
}
ModifyParagraph(pa, content);
}
/// <summary>
/// 按书签替换图片
/// </summary>
/// <param name="filePath"></param>
/// <param name="picPath"></param>
/// <param name="bm"></param>
/// <param name="x">宽度厘米</param>
/// <param name="y">高度厘米</param>
/// <param name="type"></param>
public static void ReplaceBMPicture(string filePath, string picPath, string bm, long x, ImagePartType type)
{
RemoveBookMarkContent(filePath, bm);
InsertBMPicture(filePath, picPath, bm, x, type);
}
/// <summary>
/// 按书签替换图片
/// </summary>
/// <param name="filePath"></param>
/// <param name="picPath"></param>
/// <param name="bm"></param>
/// <param name="x">宽度厘米</param>
/// <param name="y">高度厘米</param>
/// <param name="type"></param>
public static void ReplaceBMPicture(string filePath, string picPath, string bm, long x, long y, ImagePartType type)
{
RemoveBookMarkContent(filePath, bm);
InsertBMPicture(filePath, picPath, bm, x, y, type);
}
public static void ReplaceBMPicture(WordprocessingDocument doc, string picPath, string bm, long x, long y, ImagePartType type)
{
RemoveBookMarkContent(doc, bm);
InsertBMPicture(doc, picPath, bm, x, y, type);
}
/// <summary>
/// 按书签插入图片
/// </summary>
/// <param name="filePath"></param>
/// <param name="picPath"></param>
/// <param name="bm"></param>
/// <param name="x">宽度厘米</param>
/// <param name="y">高度厘米</param>
/// <param name="type"></param>
public static void InsertBMPicture(string filePath, string picPath, string bm, long x, ImagePartType type)
{
long y = 0;
using (System.Drawing.Bitmap objPic = new System.Drawing.Bitmap(picPath))
{
y = (x * objPic.Height) / objPic.Width;
}
InsertBMPicture(filePath, picPath, bm, x, y, type);
}
/// <summary>
/// 按书签插入图片
/// </summary>
/// <param name="filePath"></param>
/// <param name="picPath"></param>
/// <param name="bm"></param>
/// <param name="x">宽度厘米</param>
/// <param name="y">高度厘米</param>
/// <param name="type"></param>
public static void InsertBMPicture(string filePath, string picPath, string bm, long x, long y, ImagePartType type)
{
using (WordprocessingDocument doc = WordprocessingDocument.Open(filePath, true))
{
MainDocumentPart mainPart = doc.MainDocumentPart;
BookmarkStart bmStart = findBookMarkStart(doc, bm);
if (bmStart == null)
{
return;
}
ImagePart imagePart = mainPart.AddImagePart(type);
using (FileStream stream = new FileStream(picPath, FileMode.Open, FileAccess.Read))
{
imagePart.FeedData(stream);
}
long cx = 360000L * x;//360000L = 1厘米
long cy = 360000L * y;
Run r = AddImage(doc, mainPart.GetIdOfPart(imagePart), cx, cy);
bmStart.Parent.InsertAfter<Run>(r, bmStart);
mainPart.Document.Save();
}
}
public static void InsertBMPicture(WordprocessingDocument doc, string picPath, string bm, long x, long y, ImagePartType type)
{
MainDocumentPart mainPart = doc.MainDocumentPart;
BookmarkStart bmStart = findBookMarkStart(doc, bm);
if (bmStart == null)
{
return;
}
ImagePart imagePart = mainPart.AddImagePart(type);
using (FileStream stream = new FileStream(picPath, FileMode.Open, FileAccess.Read))
{
imagePart.FeedData(stream);
}
long cx = 360000L * x;//360000L = 1厘米
long cy = 360000L * y;
Run r = AddImage(doc, mainPart.GetIdOfPart(imagePart), cx, cy);
bmStart.Parent.InsertAfter<Run>(r, bmStart);
mainPart.Document.Save();
}
/// <summary>
/// 查找表格
/// </summary>
/// <param name="doc"></param>
/// <param name="start"></param>
/// <returns></returns>
public static Table FindTableByInnerTextStart(WordprocessingDocument doc, string start)
{
Body b = doc.MainDocumentPart.Document.Body;
foreach (var table in b.Descendants<Table>())
{
if (table.InnerText.StartsWith(start))
{
return table;
}
}
return null;
}
/// <summary>
/// 按书签插入图片。默认15厘米，JPG
/// </summary>
/// <param name="filePath"></param>
/// <param name="picPath"></param>
/// <param name="bm"></param>
public static void InsertBMPicture(string filePath, string picPath, string bm)
{
InsertBMPicture(filePath, picPath, bm, 15, 15, ImagePartType.Jpeg);
}
/// <summary>
/// 查找书签
/// </summary>
/// <param name="doc"></param>
/// <param name="bmName"></param>
/// <returns></returns>
public static BookmarkStart findBookMarkStart(WordprocessingDocument doc, string bmName)
{
foreach (var footer in doc.MainDocumentPart.FooterParts)
{
foreach (var inst in footer.Footer.Descendants<BookmarkStart>())
{
if (inst.Name == bmName)
{
return inst;
}
}
}
foreach (var header in doc.MainDocumentPart.HeaderParts)
{
foreach (var inst in header.Header.Descendants<BookmarkStart>())
{
if (inst.Name == bmName)
{
return inst;
}
}
}
foreach (var inst in doc.MainDocumentPart.RootElement.Descendants<BookmarkStart>())
{
if (inst is BookmarkStart)
{
if (inst.Name == bmName)
{
return inst;
}
}
}
return null;
}
/// <summary>
/// 查找书签
/// </summary>
/// <param name="doc"></param>
/// <param name="bmName"></param>
/// <returns></returns>
public static List<BookmarkStart> findAllBookMarkStart(WordprocessingDocument doc)
{
List<BookmarkStart> ret = new List<BookmarkStart>();
foreach (var footer in doc.MainDocumentPart.FooterParts)
{
ret.AddRange(footer.Footer.Descendants<BookmarkStart>());
}
foreach (var header in doc.MainDocumentPart.HeaderParts)
{
ret.AddRange(header.Header.Descendants<BookmarkStart>());
}
ret.AddRange(doc.MainDocumentPart.RootElement.Descendants<BookmarkStart>());
return ret;
}
/// <summary>
/// 查找书签
/// </summary>
/// <param name="doc"></param>
/// <param name="bmName"></param>
/// <returns></returns>
public static List<BookmarkEnd> findAllBookMarkEnd(WordprocessingDocument doc)
{
List<BookmarkEnd> ret = new List<BookmarkEnd>();
foreach (var footer in doc.MainDocumentPart.FooterParts)
{
ret.AddRange(footer.Footer.Descendants<BookmarkEnd>());
}
foreach (var header in doc.MainDocumentPart.HeaderParts)
{
ret.AddRange(header.Header.Descendants<BookmarkEnd>());
}
ret.AddRange(doc.MainDocumentPart.RootElement.Descendants<BookmarkEnd>());
return ret;
}
/// <summary>
/// 查找书签END
/// </summary>
/// <param name="doc"></param>
/// <param name="bmName"></param>
/// <returns></returns>
public static BookmarkEnd findBookMarkEnd(WordprocessingDocument doc, string id)
{
foreach (var footer in doc.MainDocumentPart.FooterParts)
{
foreach (var inst in footer.Footer.Descendants<BookmarkEnd>())
{
if (inst.Id == id)
{
return inst;
}
}
}
foreach (var header in doc.MainDocumentPart.HeaderParts)
{
foreach (var inst in header.Header.Descendants<BookmarkEnd>())
{
if (inst.Id == id)
{
return inst;
}
}
}
foreach (var inst in doc.MainDocumentPart.RootElement.Descendants<BookmarkEnd>())
{
if (inst.Id == id)
{
return inst;
}
}
return null;
}
/// <summary>
///
/// </summary>
/// <param name="doc"></param>
/// <param name="picPath"></param>
/// <param name="mainPart"></param>
/// <param name="r"></param>
public static void GetNewPicRun(WordprocessingDocument doc, string picPath, out MainDocumentPart mainPart, out Run r)
{
mainPart = doc.MainDocumentPart;
ImagePart imagePart = mainPart.AddImagePart(ImagePartType.Png);
long cx;
long cy;
long x = 4;
long y = 0;
using (System.Drawing.Bitmap objPic = new System.Drawing.Bitmap(picPath))
{
y = (x * objPic.Height) / objPic.Width;
}
using (FileStream stream = new FileStream(picPath, FileMode.Open, FileAccess.Read))
{
imagePart.FeedData(stream);
}
cx = 360000L * x;//360000L = 1厘米
cy = 360000L * y;
r = OpenXmlUtil.AddImage(doc, mainPart.GetIdOfPart(imagePart), cx, cy);
}
private static Run AddImage(WordprocessingDocument wordDoc, string relationshipId, long cx, long cy)
{
return new Run(new Drawing(
new DW.Inline(
new DW.Extent() { Cx = cx, Cy = cy },
new DW.EffectExtent()
{
LeftEdge = 0L,
TopEdge = 0L,
RightEdge = 0L,
BottomEdge = 0L
},
new DW.DocProperties()
{
Id = (UInt32Value)1U,
Name = "Picture 1"
},
new DW.NonVisualGraphicFrameDrawingProperties(
new AA.GraphicFrameLocks() { NoChangeAspect = true }),
new AA.Graphic(
new AA.GraphicData(
new PIC.Picture(
new PIC.NonVisualPictureProperties(
new PIC.NonVisualDrawingProperties()
{
Id = (UInt32Value)0U,
Name = "New Bitmap Image.jpg"
},
new PIC.NonVisualPictureDrawingProperties()),
new PIC.BlipFill(
new AA.Blip(
new AA.BlipExtensionList(
new AA.BlipExtension()
{
Uri =
"{28A0092B-C50C-407E-A947-70E740481C1C}"
})
)
{
Embed = relationshipId,
CompressionState =
AA.BlipCompressionValues.Print
},
new AA.Stretch(
new AA.FillRectangle())),
new PIC.ShapeProperties(
new AA.Transform2D(
new AA.Offset() { X = 0L, Y = 0L },
new AA.Extents() { Cx = 952500L, Cy = 571500L }),
new AA.PresetGeometry(
new AA.AdjustValueList()
) { Preset = AA.ShapeTypeValues.Rectangle }))
) { Uri = "http://schemas.openxmlformats.org/drawingml/2006/picture" })
)
{
DistanceFromTop = (UInt32Value)0U,
DistanceFromBottom = (UInt32Value)0U,
DistanceFromLeft = (UInt32Value)0U,
DistanceFromRight = (UInt32Value)0U,
}));
}
/// <summary>
/// 删除某一段文本
/// 1 标记1结束到标记2开始;2 标记1结束到标记2结束;3 标记1开始到标记2结束; 4 标记1开始到标记2开始;
/// </summary>
/// <param name="filePath"></param>
/// <param name="stringStart"></param>
/// <param name="stringStop"></param>
/// <param name="way"></param>
public static void DeleteRange(string filePath, string stringStart, string stringStop, int way)
{
using (WordprocessingDocument doc = WordprocessingDocument.Open(filePath, true))
{
List<OpenXmlElement> deleteList = new List<OpenXmlElement>();
bool flag = false;
foreach (var inst in doc.MainDocumentPart.Document.Body.Elements())
{
if (way == 1)
{
if (inst.InnerText.Contains(stringStop))
{
flag = false;
}
if (flag)
{
deleteList.Add(inst);
}
if (inst.InnerText.Contains(stringStart))
{
flag = true;
}
}
else if (way == 2)
{
if (flag)
{
deleteList.Add(inst);
}
if (inst.InnerText.Contains(stringStart))
{
flag = true;
}
if (inst.InnerText.Contains(stringStop))
{
flag = false;
}
}
else if (way == 3)
{
if (inst.InnerText.Contains(stringStart))
{
flag = true;
}
if (flag)
{
deleteList.Add(inst);
}
if (inst.InnerText.Contains(stringStop))
{
flag = false;
}
}
else if (way == 4)
{
if (inst.InnerText.Contains(stringStart))
{
flag = true;
}
if (inst.InnerText.Contains(stringStop))
{
flag = false;
}
if (flag)
{
deleteList.Add(inst);
}
}
}
foreach (var inst in deleteList)
{
inst.Remove();
}
}
}
/// <summary>
/// 删除某一段文本(从第二个符合的Elements开始)
/// 标记1开始到标记2开始;
/// <param name="filePath"></param>
/// <param name="stringStart"></param>
/// <param name="stringStop"></param>
/// <param name="way"></param>
public static void DeleteRangeByJieTu(string filePath, string stringStart, string stringStop)
{
using (WordprocessingDocument doc = WordprocessingDocument.Open(filePath, true))
{
List<OpenXmlElement> deleteList = new List<OpenXmlElement>();
bool flag = false;
int i = 0;
foreach (var inst in doc.MainDocumentPart.Document.Body.Elements())
{
if (inst.InnerText.Contains(stringStart))
{
if (i == 1)
{
flag = true;
}
i++;
}
if (inst.InnerText.Contains(stringStop))
{
flag = false;
}
if (flag)
{
deleteList.Add(inst);
}
}
foreach (var inst in deleteList)
{
inst.Remove();
}
}
}
/// <summary>
/// 从stringStart 开始删除到最后
/// </summary>
/// <param name="filePath"></param>
/// <param name="stringStart"></param>
/// <param name="stringStop"></param>
/// <param name="way"></param>
public static void DeleteRange(string filePath, string stringStart)
{
using (WordprocessingDocument doc = WordprocessingDocument.Open(filePath, true))
{
List<OpenXmlElement> deleteList = new List<OpenXmlElement>();
bool flag = false;
foreach (var inst in doc.MainDocumentPart.Document.Body.Elements())
{
if (inst.InnerText.Contains(stringStart))
{
flag = true;
}
if (flag)
{
deleteList.Add(inst);
}
}
foreach (var inst in deleteList)
{
inst.Remove();
}
}
}
/// <summary>
/// 从stringStart结束删除到最后，跳过第一个符合stringStart的Elements
/// 2018-10-16
/// </summary>
/// <param name="filePath"></param>
/// <param name="stringStart"></param>
public static void DeleteRangeByJieTu(string filePath, string stringStart)
{
using (WordprocessingDocument doc = WordprocessingDocument.Open(filePath, true))
{
List<OpenXmlElement> deleteList = new List<OpenXmlElement>();
bool flag = false;
int i = 0;
foreach (var inst in doc.MainDocumentPart.Document.Body.Elements())
{
if (flag)
{
deleteList.Add(inst);
}
if (inst.InnerText.Contains(stringStart))
{
if (i == 1)
{
flag = true;
}
i++;
}
}
foreach (var inst in deleteList)
{
inst.Remove();
}
}
}
public static void DeleteRangeList(List<List<OpenXmlElement>> rangeList)
{
foreach (var range in rangeList)
{
foreach (var element in range)
{
element.Remove();
}
}
}
public static void DeleteRangeList(string filePath, string stringStart, string stringStop, int way)
{
using (WordprocessingDocument doc = WordprocessingDocument.Open(filePath, true))
{
List<List<OpenXmlElement>> rangeList = new List<List<OpenXmlElement>>();
List<OpenXmlElement> temp = null;
bool add = false;
foreach (var inst in doc.MainDocumentPart.Document.Body.Elements())
{
if (way == 1)
{
if (inst.InnerText.Contains(stringStop))
{
add = false;
rangeList.Add(temp.ToList());
}
if (add)
{
temp.Add(inst);
}
if (inst.InnerText.Contains(stringStart))
{
add = true;
temp = new List<OpenXmlElement>();
}
}
else if (way == 2)
{
if (add)
{
temp.Add(inst);
}
if (inst.InnerText.Contains(stringStart))
{
add = true;
temp = new List<OpenXmlElement>();
}
if (inst.InnerText.Contains(stringStop))
{
add = false;
rangeList.Add(temp);
}
}
else if (way == 3)
{
if (inst.InnerText.Contains(stringStart))
{
add = true;
temp = new List<OpenXmlElement>();
}
if (add)
{
temp.Add(inst);
}
if (inst.InnerText.Contains(stringStop))
{
add = false;
rangeList.Add(temp);
}
}
else if (way == 4)
{
if (inst.InnerText.Contains(stringStart))
{
add = true;
temp = new List<OpenXmlElement>();
}
if (inst.InnerText.Contains(stringStop))
{
add = false;
rangeList.Add(temp);
}
if (add)
{
temp.Add(inst);
}
}
}
foreach (var range in rangeList)
{
foreach (var item in range)
{
if (item.Parent != null)
{
item.Remove();
}
}
}
}
}
/// <summary>
///
/// 1:从字符开始到最后
/// 2:从字符结束到最后
/// </summary>
/// <param name="findStr"></param>
/// <param name="way"></param>
/// <param name="huiche"></param>
public static List<OpenXmlElement> RangeFindCopy2End(string filePath, string findStr, int way)
{
List<OpenXmlElement> ret = new List<OpenXmlElement>();
bool find = false;
using (WordprocessingDocument doc = WordprocessingDocument.Open(filePath, true))
{
foreach (var inst in doc.MainDocumentPart.Document.Body.Elements())
{
if (way == 1)
{
if (inst.InnerText.Contains(findStr))
{
find = true;
}
if (find)
{
ret.Add(inst.CloneNode(true));
}
}
else if (way == 2)
{
if (find)
{
ret.Add(inst.CloneNode(true));
}
if (inst.InnerText.Contains(findStr))
{
find = true;
}
}
}
}
return ret;
}
public static List<OpenXmlElement> RangeFindCopy2End(WordprocessingDocument doc, string findStr, int way)
{
List<OpenXmlElement> ret = new List<OpenXmlElement>();
bool find = false;
foreach (var inst in doc.MainDocumentPart.Document.Body.Elements())
{
if (way == 1)
{
if (inst.InnerText.Contains(findStr))
{
find = true;
}
if (find)
{
ret.Add(inst.CloneNode(true));
}
}
else if (way == 2)
{
if (find)
{
ret.Add(inst.CloneNode(true));
}
if (inst.InnerText.Contains(findStr))
{
find = true;
}
}
}
return ret;
}
/// <summary>
/// 此方法get date 后，insert document（原始记录）页眉消失,未修改
/// </summary>
/// <param name="filePath"></param>
/// <returns></returns>
public static List<OpenXmlElement> FindWholeDoc(string filePath)
{
List<OpenXmlElement> ret = new List<OpenXmlElement>();
using (WordprocessingDocument doc = WordprocessingDocument.Open(filePath, true))
{
foreach (var inst in doc.MainDocumentPart.Document.Body.Elements())
{
ret.Add(inst.CloneNode(true));
}
}
return ret;
}
/// <summary>
/// 1 标记1结束到标记2开始;2 标记1结束到标记2结束;3 标记1开始到标记2结束; 4 标记1开始到标记2开始;
/// </summary>
/// <param name="stringStart"></param>
/// <param name="stringStop"></param>
/// <param name="way"></param>
public static List<OpenXmlElement> RangeFind(string filePath, string stringStart, string stringStop, int way)
{
using (WordprocessingDocument doc = WordprocessingDocument.Open(filePath, true))
{
return RangeFind(doc, stringStart, stringStop, way);
}
}
/// <summary>
/// 1 标记1结束到标记2开始;2 标记1结束到标记2结束;3 标记1开始到标记2结束; 4 标记1开始到标记2开始;
/// </summary>
/// <param name="stringStart"></param>
/// <param name="stringStop"></param>
/// <param name="way"></param>
public static List<OpenXmlElement> RangeFind(WordprocessingDocument doc, string stringStart, string stringStop, int way)
{
List<OpenXmlElement> ret = new List<OpenXmlElement>();
bool add = false;
foreach (var inst in doc.MainDocumentPart.Document.Body.Elements())
{
if (way == 1)
{
if (inst.InnerText.Contains(stringStop))
{
add = false;
}
if (add)
{
//if (inst is Paragraph && inst.InnerXml.Contains("w:pict"))
//{
// continue;
//}
ret.Add(inst.CloneNode(true));
}
if (inst.InnerText.Contains(stringStart))
{
add = true;
}
}
else if (way == 2)
{
if (add)
{
ret.Add(inst.CloneNode(true));
}
if (inst.InnerText.Contains(stringStart))
{
add = true;
}
if (inst.InnerText.Contains(stringStop))
{
add = false;
}
}
else if (way == 3)
{
if (inst.InnerText.Contains(stringStart))
{
add = true;
}
if (add)
{
ret.Add(inst.CloneNode(true));
}
if (inst.InnerText.Contains(stringStop))
{
add = false;
}
}
else if (way == 4)
{
if (inst.InnerText.Contains(stringStart))
{
add = true;
}
if (inst.InnerText.Contains(stringStop))
{
add = false;
}
if (add)
{
ret.Add(inst.CloneNode(true));
}
}
}
return ret;
}
/// <summary>
/// 1 标记1结束到标记2开始;2 标记1结束到标记2结束;3 标记1开始到标记2结束; 4 标记1开始到标记2开始;
/// </summary>
/// <param name="stringStart"></param>
/// <param name="stringStop"></param>
/// <param name="way"></param>
public static List<OpenXmlElement> RangeFindAll(string filePath)
{
List<OpenXmlElement> ret = new List<OpenXmlElement>();
using (WordprocessingDocument doc = WordprocessingDocument.Open(filePath, true))
{
foreach (var inst in doc.MainDocumentPart.Document.Body.Elements())
{
ret.Add(inst.CloneNode(true));
}
}
return ret;
}
public static List<List<OpenXmlElement>> RangeListFind(WordprocessingDocument doc, string stringStart, string stringStop, int way)
{
List<List<OpenXmlElement>> ret = new List<List<OpenXmlElement>>();
List<OpenXmlElement> temp = null;
bool add = false;
foreach (var inst in doc.MainDocumentPart.Document.Body.Elements())
{
if (way == 1)
{
if (inst.InnerText.Contains(stringStop))
{
add = false;
ret.Add(temp.ToList());
}
if (add)
{
temp.Add(inst.CloneNode(true));
}
if (inst.InnerText.Contains(stringStart))
{
add = true;
temp = new List<OpenXmlElement>();
}
}
else if (way == 2)
{
if (add)
{
temp.Add(inst.CloneNode(true));
}
if (inst.InnerText.Contains(stringStart))
{
add = true;
temp = new List<OpenXmlElement>();
}
if (inst.InnerText.Contains(stringStop))
{
add = false;
ret.Add(temp);
}
}
else if (way == 3)
{
if (inst.InnerText.Contains(stringStart))
{
add = true;
temp = new List<OpenXmlElement>();
}
if (add)
{
temp.Add(inst.CloneNode(true));
}
if (inst.InnerText.Contains(stringStop))
{
add = false;
ret.Add(temp);
}
}
else if (way == 4)
{
if (inst.InnerText.Contains(stringStart))
{
add = true;
temp = new List<OpenXmlElement>();
}
if (inst.InnerText.Contains(stringStop))
{
add = false;
ret.Add(temp);
}
if (add)
{
temp.Add(inst.CloneNode(true));
}
}
}
return ret;
}
/// <summary>
/// 不包含开始和结束
/// 遇见第一个字符串结束循环
/// </summary>
/// <param name="doc"></param>
/// <param name="stringStart"></param>
/// <param name="stringStop"></param>
/// <returns></returns>
public static List<List<OpenXmlElement>> RangeListFind(WordprocessingDocument doc, string stringStart, string stringStop)
{
List<List<OpenXmlElement>> ret = new List<List<OpenXmlElement>>();
List<OpenXmlElement> temp = null;
bool add = false;
foreach (var inst in doc.MainDocumentPart.Document.Body.Elements())
{
if (inst.InnerText.Contains(stringStop))
{
add = false;
ret.Add(temp.ToList());
//break;
}
if (add)
{
temp.Add(inst.CloneNode(true));
}
if (inst.InnerText.Contains(stringStart) && !add)
{
add = true;
temp = new List<OpenXmlElement>();
}
}
return ret;
}
/// <summary>
/// 修改书签
/// </summary>
/// <param name="filePath">word文档</param>
/// <param name="bmName">书签名字</param>
/// <param name="text">替换的文本</param>
public static void SetBMTxt(string filePath, string bmName, string text)
{
using (WordprocessingDocument doc = WordprocessingDocument.Open(filePath, true))
{
SetBMTxt(doc, bmName, text);
}
}
public static void SetBMTxt(WordprocessingDocument doc, string bmName, string text)
{
BookmarkStart bs = findBookMarkStart(doc, bmName);
if (bs != null)
{
OpenXmlElement elem = bs.NextSibling();
while (elem != null && !(elem is BookmarkEnd))
{
OpenXmlElement nextElem = elem.NextSibling();
elem.Remove();
elem = nextElem;
}
bs.Parent.InsertAfter<Run>(new Run(new Text(text)), bs);
}
}
/// <summary>
/// 删除书签内容(目前适用于书签内无表格)
/// </summary>
/// <param name="bookmark"></param>
public static void DeleteBookMarkAndContent(string filePath, string bmName)
{
RemoveBookMarkContent(filePath, bmName);
RemoveBookMark(filePath, bmName);
}
public static void DeleteBookMarkAndContent(WordprocessingDocument doc, string bmName)
{
RemoveBookMarkContent(doc, bmName);
RemoveBookMark(doc, bmName);
}
/// <summary>
///
/// 1:文档开始到字符开始
/// 2:文档开始到字符结束
/// true:包括回车
/// </summary>
/// <param name="findStr"></param>
/// <param name="way"></param>
/// <param name="huiche"></param>
public static List<OpenXmlElement> RangeFindCopyFromStart(string filePath, string findStr, int way)
{
List<OpenXmlElement> ret = new List<OpenXmlElement>();
using (WordprocessingDocument doc = WordprocessingDocument.Open(filePath, true))
{
foreach (var inst in doc.MainDocumentPart.Document.Body.Elements())
{
if (way == 1)
{
if (inst.InnerText.Contains(findStr))
{
break;
}
ret.Add(inst.CloneNode(true));
}
else if (way == 2)
{
ret.Add(inst.CloneNode(true));
if (inst.InnerText.Contains(findStr))
{
break;
}
}
}
}
return ret;
}
/// <summary>
/// 把elements复制到文件的最后面
/// </summary>
/// <param name="filePath"></param>
/// <param name="elements"></param>
public static void PasteDocumentEnd(string filePath, List<OpenXmlElement> elements)
{
using (WordprocessingDocument doc = WordprocessingDocument.Open(filePath, true))
{
PasteDocumentEnd(doc, elements);
}
}
public static void PasteDocumentEnd(WordprocessingDocument doc, List<OpenXmlElement> elements)
{
Body b = doc.MainDocumentPart.Document.Body;
OpenXmlElement flag = b.Elements().LastOrDefault();
if (flag == null)
{
return;
}
foreach (var inst in elements)
{
b.InsertBefore(inst, flag);
}
}
/// <summary>
/// 删除书签内容(目前适用于书签内无表格)
/// </summary>
/// <param name="bookmark"></param>
public static void RemoveBookMarkContent(string filePath, string bmName)
{
using (WordprocessingDocument doc = WordprocessingDocument.Open(filePath, true))
{
RemoveBookMarkContent(doc, bmName);
}
}
/// <summary>
/// 删除书签内容(目前适用于书签内无表格)
/// </summary>
/// <param name="doc"></param>
/// <param name="bmName"></param>
public static void RemoveBookMarkContent(WordprocessingDocument doc, string bmName)
{
BookmarkStart bmStart = findBookMarkStart(doc, bmName);
BookmarkEnd bmEnd = findBookMarkEnd(doc, bmStart.Id);
while (true)
{
var run = bmStart.NextSibling();
if (run == null)
{
break;
}
if (run is BookmarkEnd && (BookmarkEnd)run == bmEnd)
{
break;
}
run.Remove();
}
}
/// <summary>
/// 重命名书签，在书签前面加前缀
/// </summary>
/// <param name="filePath"></param>
/// <param name="prefix">前缀</param>
public static void PrefixBookMark(string filePath, string prefix)
{
using (WordprocessingDocument doc = WordprocessingDocument.Open(filePath, true))
{
foreach (var inst in findAllBookMarkStart(doc))
{
inst.Name = prefix + inst.Name;
}
}
}
/// <summary>
/// 重命名书签
/// </summary>
/// <param name="filePath"></param>
/// <param name="oldName"></param>
/// <param name="newName"></param>
public static void RenameBookMark(string filePath, string oldName, string newName)
{
using (WordprocessingDocument doc = WordprocessingDocument.Open(filePath, true))
{
var bm = findBookMarkStart(doc, oldName);
bm.Name = newName;
}
}
/// <summary>
/// 重命名书签
/// </summary>
/// <param name="filePath"></param>
/// <param name="oldName"></param>
/// <param name="newName"></param>
public static void RenameBookMark(WordprocessingDocument doc, string oldName, string newName)
{
var bm = findBookMarkStart(doc, oldName);
bm.Name = newName;
}
/// <summary>
/// 删除书签
/// </summary>
/// <param name="bookmark"></param>
public static void RemoveBookMark(string filePath, string bmName)
{
using (WordprocessingDocument doc = WordprocessingDocument.Open(filePath, true))
{
RemoveBookMark(doc, bmName);
}
}
/// <summary>
/// 删除书签
/// </summary>
/// <param name="filePath"></param>
/// <param name="bmName"></param>
public static void RemoveBookMark(WordprocessingDocument doc, string bmName)
{
var bmStart = findBookMarkStart(doc, bmName);
if (bmStart == null)
{
return;
}
var bmEnd = findBookMarkEnd(doc, bmStart.Id);
bmStart.Remove();
bmEnd.Remove();
}
/// <summary>
/// 删除书签所在的Paragraph:
/// </summary>
/// <param name="filePath"></param>
/// <param name="bmName"></param>
public static void RemoveBookMarkAndParagraph(string filePath, string bmName)
{
using (WordprocessingDocument doc = WordprocessingDocument.Open(filePath, true))
{
var bmStart = findBookMarkStart(doc, bmName);
if (bmStart == null)
{
return;
}
bmStart.Parent.Remove();
}
}
public static void InsertBefore(string filePath, string findStr, List<OpenXmlElement> datas)
{
using (WordprocessingDocument doc = WordprocessingDocument.Open(filePath, true))
{
Body b = doc.MainDocumentPart.Document.Body;
OpenXmlElement flag = b.Elements().FirstOrDefault();
foreach (var inst in b.Elements())
{
if (inst.InnerText.Contains(findStr))
{
flag = inst;
break;
}
}
foreach (var inst in datas)
{
b.InsertBefore(inst, flag);
}
}
}
/// <summary>
///
/// </summary>
/// <param name="filePath"></param>
/// <param name="findStr"></param>
/// <param name="findStrIndex">start 0</param>
/// <param name="datas"></param>
public static void InsertBefore(string filePath, string findStr, int findStrIndex, List<OpenXmlElement> datas)
{
using (WordprocessingDocument doc = WordprocessingDocument.Open(filePath, true))
{
Body b = doc.MainDocumentPart.Document.Body;
OpenXmlElement flag = b.Elements().FirstOrDefault();
var flagList = b.Elements().Where(p => p.InnerText.Contains(findStr)).ToList();
if (findStrIndex >= flagList.Count)
{
return;
}
flag = flagList[findStrIndex];
foreach (var inst in datas)
{
var newOpenXmlElement = inst.CloneNode(true);
b.InsertBefore(newOpenXmlElement, flag);
}
}
}
/// <summary>
///
/// </summary>
/// <param name="filePath"></param>
/// <param name="findStr"></param>
/// <param name="findStrIndex">start 0</param>
/// <param name="datas"></param>
public static void InsertBefore(WordprocessingDocument doc, string findStr, int findStrIndex, List<OpenXmlElement> datas)
{
Body b = doc.MainDocumentPart.Document.Body;
OpenXmlElement flag = b.Elements().FirstOrDefault();
var flagList = b.Elements().Where(p => p.InnerText.Contains(findStr)).ToList();
if (findStrIndex >= flagList.Count)
{
return;
}
flag = flagList[findStrIndex];
foreach (var inst in datas)
{
var newOpenXmlElement = inst.CloneNode(true);
b.InsertBefore(newOpenXmlElement, flag);
}
}
/// <summary>
/// 杀进程
/// </summary>
public static void KillWinWordProcess()
{
Process[] processes = Process.GetProcesses();
foreach (Process pr in processes)
{
if (pr.ProcessName.ToLower().Contains("winword"))
{
pr.Kill();
}
}
Thread.Sleep(1000);
}
/// <summary>
///
/// </summary>
/// <param name="filePath"></param>
/// <param name="findStr"></param>
/// <param name="findStrIndex">start 0</param>
/// <param name="datas"></param>
public static void InsertBefore(string filePath, string findStr, int findStrIndex, List<Paragraph> datas)
{
using (WordprocessingDocument doc = WordprocessingDocument.Open(filePath, true))
{
Body b = doc.MainDocumentPart.Document.Body;
OpenXmlElement flag = b.Elements().FirstOrDefault();
var flagList = b.Elements().Where(p => p.InnerText.Contains(findStr)).ToList();
if (findStrIndex >= flagList.Count)
{
return;
}
flag = flagList[findStrIndex];
foreach (var inst in datas)
{
var newOpenXmlElement = inst.CloneNode(true);
b.InsertBefore(newOpenXmlElement, flag);
}
}
}
public static void InsertAfter(string filePath, string findStr, int findStrIndex, List<OpenXmlElement> datas)
{
using (WordprocessingDocument doc = WordprocessingDocument.Open(filePath, true))
{
Body b = doc.MainDocumentPart.Document.Body;
OpenXmlElement flag = b.Elements().FirstOrDefault();
var flagList = b.Elements().Where(p => p.InnerText.Contains(findStr)).ToList();
if (findStrIndex >= flagList.Count)
{
return;
}
flag = flagList[findStrIndex];
datas.Reverse();
foreach (var inst in datas)
{
b.InsertAfter(inst, flag);
}
}
}
public static void InsertAfter(WordprocessingDocument doc, string findStr, int findStrIndex, List<OpenXmlElement> datas)
{
Body b = doc.MainDocumentPart.Document.Body;
OpenXmlElement flag = b.Elements().FirstOrDefault();
var flagList = b.Elements().Where(p => p.InnerText.Contains(findStr)).ToList();
if (findStrIndex >= flagList.Count)
{
return;
}
flag = flagList[findStrIndex];
datas.Reverse();
foreach (var inst in datas)
{
b.InsertAfter(inst, flag);
}
}
/// <summary>
///在findStr下插入内容 paragraph必须等于findStr才可以插入，包含不会插入
/// </summary>
/// <param name="filePath"></param>
/// <param name="findStr"></param>
/// <param name="findStrIndex"></param>
/// <param name="datas"></param>
public static void InsertAfterByEquelsFindStr(string filePath, string findStr, int findStrIndex, List<OpenXmlElement> datas)
{
using (WordprocessingDocument doc = WordprocessingDocument.Open(filePath, true))
{
Body b = doc.MainDocumentPart.Document.Body;
OpenXmlElement flag = b.Elements().FirstOrDefault();
var flagList = b.Elements().Where(p => p.InnerText.Equals(findStr)).ToList();
if (findStrIndex >= flagList.Count)
{
return;
}
flag = flagList[findStrIndex];
datas.Reverse();
foreach (var inst in datas)
{
b.InsertAfter(inst, flag);
}
}
}
public static void InsertBefore(string filePath, string findStr, OpenXmlElement data)
{
using (WordprocessingDocument doc = WordprocessingDocument.Open(filePath, true))
{
Body b = doc.MainDocumentPart.Document.Body;
OpenXmlElement flag = b.Elements().FirstOrDefault();
foreach (var inst in b.Elements())
{
if (inst.InnerText.Contains(findStr))
{
flag = inst;
break;
}
}
flag.InsertBeforeSelf(data);
}
}
public static void InsertBreakAfter(string filePath, string findStr)
{
using (WordprocessingDocument doc = WordprocessingDocument.Open(filePath, true))
{
Body b = doc.MainDocumentPart.Document.Body;
OpenXmlElement flag = b.Elements().FirstOrDefault();
foreach (var inst in b.Elements())
{
if (inst.InnerText.Contains(findStr))
{
flag = inst;
break;
}
}
Break break1 = new Break() { Type = BreakValues.Page };
Run run2 = new Run();
run2.Append(break1);
Paragraph p1 = new Paragraph();
p1.Append(run2);
flag.Append(p1);
}
}
public static void InsertBreakAfter(string filePath, string findStr, int findStrIndex)
{
using (WordprocessingDocument doc = WordprocessingDocument.Open(filePath, true))
{
Body b = doc.MainDocumentPart.Document.Body;
OpenXmlElement flag = b.Elements().FirstOrDefault();
var flagList = b.Elements().Where(p => p.InnerText.Contains(findStr)).ToList();
if (findStrIndex >= flagList.Count)
{
return;
}
flag = flagList[findStrIndex];
Break break1 = new Break() { Type = BreakValues.Page };
Run run2 = new Run();
run2.Append(break1);
Paragraph p1 = new Paragraph();
p1.Append(run2);
flag.Append(p1);
}
}
public static void InsertBreakBefore(string filePath, string findStr, int findStrIndex)
{
using (WordprocessingDocument doc = WordprocessingDocument.Open(filePath, true))
{
Body b = doc.MainDocumentPart.Document.Body;
OpenXmlElement flag = b.Elements().FirstOrDefault();
var flagList = b.Elements().Where(p => p.InnerText.Contains(findStr)).ToList();
if (findStrIndex >= flagList.Count)
{
return;
}
flag = flagList[findStrIndex];
Break break1 = new Break() { Type = BreakValues.Page };
Run run2 = new Run();
run2.Append(break1);
Paragraph p1 = new Paragraph();
p1.Append(run2);
flag.InsertBeforeSelf(p1);
}
}
public static void InsertBreakBefore(string filePath, string findStr)
{
using (WordprocessingDocument doc = WordprocessingDocument.Open(filePath, true))
{
Body b = doc.MainDocumentPart.Document.Body;
var flagList = b.Elements().Where(p => p.InnerText.Contains(findStr)).ToList();
foreach (var flag in flagList)
{
Break break1 = new Break() { Type = BreakValues.Page };
Run run2 = new Run();
run2.Append(break1);
Paragraph p1 = new Paragraph();
p1.Append(run2);
flag.InsertBeforeSelf(p1);
}
}
}
/// <summary>
/// 在文档最后插入一个分页符
/// </summary>
/// <param name="filePath"></param>
public static void InsertBreakEnd(string filePath)
{
using (WordprocessingDocument doc = WordprocessingDocument.Open(filePath, true))
{
InsertBreakEnd(doc);
}
}
public static void InsertBreakEnd(WordprocessingDocument doc)
{
Body b = doc.MainDocumentPart.Document.Body;
OpenXmlElement flag = b.Elements<Paragraph>().LastOrDefault();
Break break1 = new Break() { Type = BreakValues.Page };
Run run2 = new Run();
run2.Append(break1);
Paragraph p1 = new Paragraph();
p1.Append(run2);
flag.InsertAfterSelf(p1);
}
/// <summary>
/// 在文档开头插入一个分页符
/// </summary>
/// <param name="filePath"></param>
public static void InsertBreakStart(string filePath)
{
using (WordprocessingDocument doc = WordprocessingDocument.Open(filePath, true))
{
Body b = doc.MainDocumentPart.Document.Body;
OpenXmlElement flag = b.Elements<Paragraph>().FirstOrDefault();
Paragraph p1 = new Paragraph();
Break break1 = new Break() { Type = BreakValues.Page };
Run run1 = new Run();
run1.Append(break1);
p1.Append(run1);
b.InsertBefore(p1, flag);
}
}
/// <summary>
/// 在paragraph之前插入分页符
/// </summary>
/// <param name="paragraph"></param>
public static void InsertBreakByPragraph(Paragraph paragraph)
{
Paragraph paragraph1 = new Paragraph() { RsidParagraphAddition = "00F221A5", RsidRunAdditionDefault = "00F221A5" };
ParagraphProperties paragraphProperties1 = new ParagraphProperties();
WidowControl widowControl1 = new WidowControl();
Justification justification1 = new Justification() { Val = JustificationValues.Left };
paragraphProperties1.Append(widowControl1);
paragraphProperties1.Append(justification1);
Run run1 = new Run();
Break break1 = new Break() { Type = BreakValues.Page };
run1.Append(break1);
paragraph1.Append(paragraphProperties1);
paragraph1.Append(run1);
paragraph.InsertBeforeSelf(paragraph1);
}
/// <summary>
///
/// </summary>
/// <param name="wordPath"></param>
/// <param name="keyWords">要修改的TableCell里的Paragraph的Text</param>
/// <param name="innerText"></param>
/// <param name="rowIndex"></param>
/// <param name="cellIndex"></param>
public static void ModifyTableFreRange(string wordPath, string keyWords, string innerText)
{
using (WordprocessingDocument doc = WordprocessingDocument.Open(wordPath, true))
{
var paras = doc.MainDocumentPart.Document.Body.Descendants<Paragraph>().Where(p => p.InnerText.Contains("被测设备主要技术参数描述"));
if (paras != null && paras.Count() != 0)
{
var tableRows = paras.First().NextSibling<Table>().Where(p => p.InnerText.Contains(keyWords));
if (tableRows != null && tableRows.Count() != 0)
{
var para = ((TableRow)tableRows.First()).Descendants<Paragraph>().Where(p => p.InnerText.Contains(keyWords));
if (para != null && para.Count() != 0)
{
ModifyParagraph(para.First(), innerText);
}
}
}
}
}
#region Oper Table
/// <summary>
/// innerTxt唯一则表唯一，List<Table> count=1
/// </summary>
/// <param name="doc"></param>
/// <param name="innerTxt"></param>
/// <param name="condition">0:StartsWith,1:Contains,2:EndsWith</param>
/// <returns></returns>
public static List<Table> FindTableByInnerText(WordprocessingDocument doc, string innerTxt, int condition)
{
List<Table> list = new List<Table>();
Body b = doc.MainDocumentPart.Document.Body;
foreach (Table inst in b.Descendants<Table>())
{
Table table = null;
if (condition == 0)
{
if (inst.InnerText.StartsWith(innerTxt))
{
table = inst;
}
}
else if (condition == 1)
{
if (inst.InnerText.Contains(innerTxt))
{
table = inst;
}
}
else if (condition == 2)
{
if (inst.InnerText.EndsWith(innerTxt))
{
table = inst;
}
}
if (table != null)
{
list.Add(table);
}
}
return list;
}
/// <summary>
///
/// </summary>
/// <param name="filePath"></param>
/// <param name="innerTxt"></param>
/// <param name="condition">0:StartsWith,1:Contains,2:EndsWith</param>
public static void DeleteTablesByInnerText(string filePath, string innerTxt, int condition)
{
using (WordprocessingDocument doc = WordprocessingDocument.Open(filePath, true))
{
var tables = FindTableByInnerText(doc, innerTxt, condition);
if (tables != null)
{
foreach (var inst in tables)
{
inst.Remove();
}
}
}
}
/// <summary>
///
/// </summary>
/// <param name="filePath"></param>
/// <param name="rowInnerTxt"></param>
/// <param name="rowCondition">0:StartsWith,1:Contains,2:EndsWith</param>
private static void DeleteTableRowByInnerText(Table table, string rowInnerTxt, int rowCondition)
{
if (table != null)
{
TableRow row = null;
foreach (TableRow inst in table.Descendants<TableRow>())
{
switch (rowCondition)
{
case 0:
if (inst.InnerText.StartsWith(rowInnerTxt))
{
row = inst;
}
break;
case 1:
if (inst.InnerText.Contains(rowInnerTxt))
{
row = inst;
}
break;
case 2:
if (inst.InnerText.EndsWith(rowInnerTxt))
{
row = inst;
}
break;
default:
row = null;
break;
}
}
if (row != null)
{
row.Remove();
}
}
}
/// <summary>
/// 删除FDD杂散发射部分
/// </summary>
/// <param name="filePath"></param>
/// <param name="tableInnerTxt"></param>
/// <param name="tableCondition"></param>
/// <param name="rowInnerTxt"></param>
/// <param name="rowCondition"></param>
public static void DeleteFDDZaSanByInnerText(string filePath, string tableInnerTxt, int tableCondition, string rowInnerTxt, int rowCondition)
{
using (WordprocessingDocument doc = WordprocessingDocument.Open(filePath, true))
{
var table = OpenXmlUtil.FindTableByInnerText(doc, tableInnerTxt, tableCondition).FirstOrDefault();
if (table != null)
{
List<DocumentFormat.OpenXml.Wordprocessing.TableRow> rList = new List<DocumentFormat.OpenXml.Wordprocessing.TableRow>();
DocumentFormat.OpenXml.Wordprocessing.TableRow row = null;
foreach (DocumentFormat.OpenXml.Wordprocessing.TableRow inst in table.Descendants<DocumentFormat.OpenXml.Wordprocessing.TableRow>())
{
switch (rowCondition)
{
case 0:
if (inst.InnerText.StartsWith(rowInnerTxt))
{
row = inst;
}
break;
case 1:
if (inst.InnerText.Contains(rowInnerTxt))
{
row = inst;
}
break;
case 2:
if (inst.InnerText.EndsWith(rowInnerTxt))
{
row = inst;
}
break;
default:
row = null;
break;
}
//
if (row != null)
{
var firstCell = inst.GetFirstChild<DocumentFormat.OpenXml.Wordprocessing.TableCell>();
//if (row != inst && !string.IsNullOrEmpty(firstCell.InnerText))
//{
// break;
//}
if (row != inst && firstCell.TableCellProperties.VerticalMerge.Val != null && firstCell.TableCellProperties.VerticalMerge.Val == MergedCellValues.Restart)
{
break;
}
rList.Add(inst);
}
}
if (rList != null)
{
foreach (var inst in rList)
{
inst.Remove();
}
}
}
}
}
/// <summary>
///
/// </summary>
/// <param name="filePath"></param>
/// <param name="tableInnerTxt"></param>
/// <param name="tableCondition">0:StartsWith,1:Contains,2:EndsWith</param>
/// <param name="rowInnerTxt"></param>
/// <param name="rowCondition">0:StartsWith,1:Contains,2:EndsWith</param>
public static void DeleteTableRowByInnerText(string filePath, string tableInnerTxt, int tableCondition, string rowInnerTxt, int rowCondition)
{
using (WordprocessingDocument doc = WordprocessingDocument.Open(filePath, true))
{
var tables = FindTableByInnerText(doc, tableInnerTxt, tableCondition);
if (tables != null)
{
foreach (var inst in tables)
{
DeleteTableRowByInnerText(inst, rowInnerTxt, rowCondition);
}
}
}
}
#endregion
public static void ModifyParagraph(Paragraph pa, string content)
{
Run run = new Run();
if (pa.Elements<Run>().Count() > 0)
{
run = (Run)pa.Elements<Run>().FirstOrDefault().CloneNode(true);
pa.RemoveAllChildren<Run>();
run.RemoveAllChildren<Text>();
}
else
{
run = new Run();
}
Text t = new Text(content);
run.Append(t);
pa.Append(run);
}
/// <summary>
///
/// </summary>
/// <param name="filePath"></param>
/// <param name="content"></param>
/// <param name="phInnerTxt"></param>
/// <param name="condition">0:StartsWith,1:Contains,2:EndsWith</param>
public static void ModifyParagraph(string filePath, string content, string phInnerTxt, int condition)
{
using (WordprocessingDocument doc = WordprocessingDocument.Open(filePath, true))
{
List<Paragraph> phList = FindParaByInnerTxt(doc, phInnerTxt, condition);
foreach (var inst in phList)
{
ModifyParagraph(inst, content);
}
}
}
private static void FindAllParaRecursive(OpenXmlElement element, List<Paragraph> paragraphList)
{
if (element is Paragraph)
{
paragraphList.Add((Paragraph)element);
}
foreach (var inst in element.Elements())
{
FindAllParaRecursive(inst, paragraphList);
}
}
/// <summary>
/// 查找所有书签
/// </summary>
/// <param name="doc"></param>
/// <returns></returns>
public static List<string> FindAllBookmark(WordprocessingDocument doc)
{
var retList = new List<string>();
foreach (var footer in doc.MainDocumentPart.FooterParts)
{
foreach (var inst in footer.Footer.Descendants<BookmarkStart>())
{
retList.Add(inst.Name);
}
}
foreach (var header in doc.MainDocumentPart.HeaderParts)
{
foreach (var inst in header.Header.Descendants<BookmarkStart>())
{
retList.Add(inst.Name);
}
}
foreach (var inst in doc.MainDocumentPart.RootElement.Descendants<BookmarkStart>())
{
if (inst is BookmarkStart)
{
retList.Add(inst.Name);
}
}
return retList;
}
/// <summary>
///得到书签内容
/// </summary>
/// <param name="bookmark"></param>
/// <returns></returns>
public static string GetTheBookMarkText(BookmarkStart bookmark)
{
string str = string.Empty;
if (bookmark == null)
{
return str;
}
//紧邻元素
OpenXmlElement elem = bookmark.NextSibling();
while (elem != null && !(elem is BookmarkEnd))
{
if (elem is Run)
{
str += elem.InnerText;
}
elem = elem.NextSibling();
}
return str;
}
public static List<Paragraph> FindAllPara(WordprocessingDocument doc)
{
List<Paragraph> paragraphList = new List<Paragraph>();
Body b = doc.MainDocumentPart.Document.Body;
foreach (var inst in b.Elements())
{
FindAllParaRecursive(inst, paragraphList);
}
return paragraphList;
}
/// <summary>
///
/// </summary>
/// <param name="doc"></param>
/// <param name="innerTxt"></param>
/// <param name="condition">0:StartsWith,1:Contains,2:EndsWith</param>
/// <returns></returns>
public static List<Paragraph> FindParaByInnerTxt(WordprocessingDocument doc, string innerTxt, int condition)
{
Paragraph ph = null;
List<Paragraph> phList = new List<Paragraph>();
List<Paragraph> allPhList = FindAllPara(doc);
foreach (var inst in allPhList)
{
if (inst == null || string.IsNullOrEmpty(inst.InnerText))
{
continue;
}
if (condition == 0)
{
if (inst.InnerText.StartsWith(innerTxt))
{
ph = inst;
}
else { ph = null; }
}
else if (condition == 1)
{
if (inst.InnerText.Contains(innerTxt))
{
ph = inst;
}
else { ph = null; }
}
else if (condition == 2)
{
if (inst.InnerText.EndsWith(innerTxt))
{
ph = inst;
}
else { ph = null; }
}
if (ph != null)
{
phList.Add(ph);
}
}
return phList;
}
/// <summary>
/// 获得整机辐射模块名称
/// </summary>
/// <param name="filePath"></param>
/// <returns></returns>
public static string GetModelNameByOpenXml(string filePath)
{
string modelName = string.Empty;
using (WordprocessingDocument doc = WordprocessingDocument.Open(filePath, true))
{
var paras = doc.MainDocumentPart.Document.Body.Elements<Paragraph>();
foreach (var para in paras)
{
if (para.InnerText.Contains("模块") && para.InnerText.EndsWith("部分"))
{
string[] modelNames = para.InnerText.Split(new char[] { '：' }, StringSplitOptions.RemoveEmptyEntries);
modelName = modelNames[modelNames.Count() - 1];
break;
}
}
return modelName;
}
}
/// <summary>
/// 获得整机辐射模块名称
/// </summary>
/// <param name="filePath"></param>
/// <returns></returns>
public static List<string> GetModelNamesByOpenXml(string filePath)
{
List<string> modelNameList = new List<string>();
using (WordprocessingDocument doc = WordprocessingDocument.Open(filePath, true))
{
var paras = doc.MainDocumentPart.Document.Body.Elements<Paragraph>();
foreach (var para in paras)
{
if (para.InnerText.Contains("模块") && para.InnerText.EndsWith("部分"))
{
string[] modelNames = para.InnerText.Split(new char[] { '：' }, StringSplitOptions.RemoveEmptyEntries);
modelNameList.Add(modelNames[modelNames.Count() - 1]);
}
}
return modelNameList;
}
}
/// <summary>
/// 得到正文中numId
/// </summary>
/// <param name="wordPath"></param>
/// <returns></returns>
public static int GetNumId(string wordPath)
{
bool flag = false;
using (WordprocessingDocument doc = WordprocessingDocument.Open(wordPath, true))
{
var paras = doc.MainDocumentPart.Document.Body.Elements<Paragraph>();
int index = 0;
if (paras != null)
{
foreach (Paragraph para in paras.ToList())
{
if (para.InnerText.StartsWith("附件：检测数据及被测设备照片"))
{
if (index == 1)
{
flag = true;
}
index++;
continue;
}
if (flag)
{
if (para.ParagraphProperties != null)
{
foreach (NumberingProperties id in para.ParagraphProperties.Elements<NumberingProperties>())
{
return id.NumberingId.Val;
}
}
}
}
}
}
return -1;
}
public static int GetPicNumId(string wordPath)
{
bool flag = false;
using (WordprocessingDocument doc = WordprocessingDocument.Open(wordPath, true))
{
var paras = doc.MainDocumentPart.Document.Body.Elements<Paragraph>();
if (paras != null)
{
foreach (Paragraph para in paras.ToList())
{
if (para.InnerText.StartsWith("附件：检测截图"))
{
flag = true;
continue;
}
if (flag)
{
if (para.ParagraphProperties != null)
{
foreach (NumberingProperties id in para.ParagraphProperties.Elements<NumberingProperties>())
{
return id.NumberingId.Val;
}
}
}
}
}
}
return -1;
}
public static int GetAbstractNumId(string wordPath, string numId)
{
int abstractNumId = -1;
using (WordprocessingDocument doc = WordprocessingDocument.Open(wordPath, true))
{
Numbering numbering = doc.MainDocumentPart.NumberingDefinitionsPart.Numbering;
var numInstances = numbering.Elements<NumberingInstance>().Where(p => p.NumberID == numId);
if (numInstances != null && numInstances.Count() != 0)
{
abstractNumId = ((NumberingInstance)numInstances.First()).AbstractNumId.Val;
}
}
return abstractNumId;
}
public static int AddNumberingInstance(string wordPath)
{
int id = -1;
int numId = GetNumId(wordPath);
if (numId == -1)
{
return id;
}
int abstractNumId = GetAbstractNumId(wordPath, numId.ToString());
if (abstractNumId == -1)
{
return id;
}
using (WordprocessingDocument doc = WordprocessingDocument.Open(wordPath, true))
{
Numbering numbering = doc.MainDocumentPart.NumberingDefinitionsPart.Numbering;
NumberingInstance instance = new NumberingInstance() { NumberID = numbering.Elements<NumberingInstance>().Count() + 1 };
instance.AppendChild<AbstractNumId>(new AbstractNumId() { Val = abstractNumId });
CreateLevel(instance);
numbering.AppendChild<NumberingInstance>(instance);
id = instance.NumberID;
}
return id;
}
public static int AddNumberingInstancePic(string wordPath)
{
int id = -1;
int numId = GetPicNumId(wordPath);
if (numId == -1)
{
return id;
}
int abstractNumId = GetAbstractNumId(wordPath, numId.ToString());
if (abstractNumId == -1)
{
return id;
}
using (WordprocessingDocument doc = WordprocessingDocument.Open(wordPath, true))
{
Numbering numbering = doc.MainDocumentPart.NumberingDefinitionsPart.Numbering;
NumberingInstance instance = new NumberingInstance() { NumberID = numbering.Elements<NumberingInstance>().Count() + 1 };
instance.AppendChild<AbstractNumId>(new AbstractNumId() { Val = abstractNumId });
CreateLevel(instance);
numbering.AppendChild<NumberingInstance>(instance);
id = instance.NumberID;
}
return id;
}
public static void CreateLevel(NumberingInstance instance)
{
string str = string.Empty;
for (int i = 1; i <= 9; i++)
{
str = i == 1 ? "%" + i : str + "." + "%" + i;
CreateLevelOverRide(instance, i - 1, 1, str);
}
}
public static void CreateLevelOverRide(NumberingInstance instance, int levelIndex, int start, string levelText)
{
LevelOverride levelOverRide = new LevelOverride() { LevelIndex = levelIndex };
Level lev = new Level(
new StartOverrideNumberingValue() { Val = start },
new NumberingFormat() { Val = NumberFormatValues.Decimal },
new LevelSuffix() { Val = LevelSuffixValues.Space },
new LevelText() { Val = levelText },
new LevelJustification() { Val = LevelJustificationValues.Left },
new PreviousParagraphProperties(
new Indentation() { Left = "0" }),
new NumberingSymbolRunProperties(
new RunFonts() { Hint = FontTypeHintValues.EastAsia })
) { LevelIndex = levelIndex };
levelOverRide.Append(lev);
instance.Append(levelOverRide);
}
#region 合并同Band刷序号
public static void ModifyBandNumId(string wordPath, int sortWordPathListCount)
{
List<int> numsId = new List<int>();
for (int i = 0; i < sortWordPathListCount; i++)
{
int id = AddBandNumberingInstance(wordPath);
if (id == -1)//id==-1，则说明未找到numId.
{
return;
}
numsId.Add(id);
}
ModifyBandNumId(wordPath, numsId);
}
public static int AddBandNumberingInstance(string wordPath)
{
int id = -1;
int numId = GetBandNumId(wordPath);
if (numId == -1)
{
return id;
}
int abstractNumId = GetAbstractNumId(wordPath, numId.ToString());
if (abstractNumId == -1)
{
return id;
}
using (WordprocessingDocument doc = WordprocessingDocument.Open(wordPath, true))
{
Numbering numbering = doc.MainDocumentPart.NumberingDefinitionsPart.Numbering;
NumberingInstance instance = new NumberingInstance() { NumberID = numbering.Elements<NumberingInstance>().Count() + 1 };
instance.AppendChild<AbstractNumId>(new AbstractNumId() { Val = abstractNumId });
CreateLevel(instance);
numbering.AppendChild<NumberingInstance>(instance);
id = instance.NumberID;
}
return id;
}
public static int GetBandNumId(string wordPath)
{
bool flag = false;
using (WordprocessingDocument doc = WordprocessingDocument.Open(wordPath, true))
{
var paras = doc.MainDocumentPart.Document.Body.Elements<Paragraph>();
if (paras != null)
{
foreach (Paragraph para in paras.ToList())
{
if (para.InnerText.StartsWith("原始记录"))
{
flag = true;
continue;
}
if (flag)
{
if (para.ParagraphProperties != null)
{
foreach (NumberingProperties id in para.ParagraphProperties.Elements<NumberingProperties>())
{
return id.NumberingId.Val;
}
}
}
}
}
}
return -1;
}
private static void ModifyBandNumId(string wordPath, List<int> numsId)
{
using (WordprocessingDocument doc = WordprocessingDocument.Open(wordPath, true))
{
var paras = doc.MainDocumentPart.Document.Body.Elements<Paragraph>();
bool flag = false;
int index = 0;
if (paras != null)
{
foreach (Paragraph para in paras.ToList())
{
if (para.InnerText.StartsWith("原始记录"))
{
flag = true;
index = 2;
continue;
}
if (flag == true)
{
if (para.ParagraphProperties != null)
{
foreach (NumberingProperties id in para.ParagraphProperties.Elements<NumberingProperties>())
{
if (index - 2 < numsId.Count)
{
id.NumberingId.Val = numsId[index - 2];
}
}
}
}
}
}
}
}
#endregion
/// <summary>
/// 修改编号
/// </summary>
/// <param name="wordPath"></param>
/// <param name="sortWordPathListCount">word数量</param>
public static void ModifyNumId(string wordPath, int sortWordPathListCount)
{
List<int> numsId = new List<int>();
for (int i = 0; i < sortWordPathListCount; i++)
{
int id = AddNumberingInstance(wordPath);
if (id == -1)//id==-1，则说明未找到numId.
{
return;
}
numsId.Add(id);
}
ModifyNumId(wordPath, numsId);
}
public static void ModifyPicNumId(string wordPath, int sortWordPathListCount)
{
List<int> numsId = new List<int>();
for (int i = 0; i < sortWordPathListCount; i++)
{
int id = AddNumberingInstancePic(wordPath);
if (id == -1)//id==-1，则说明未找到numId.
{
return;
}
numsId.Add(id);
}
ModifyPicNumId(wordPath, numsId);
}
private static void ModifyPicNumId(string wordPath, List<int> numsId)
{
using (WordprocessingDocument doc = WordprocessingDocument.Open(wordPath, true))
{
var paras = doc.MainDocumentPart.Document.Body.Elements<Paragraph>();
bool flag = false;
int index = 0;
if (paras != null)
{
foreach (Paragraph para in paras.ToList())
{
if (para.InnerText.StartsWith("检测截图*"))
{
flag = true;
index = 2;
continue;
}
if (flag == true)
{
if (para.ParagraphProperties != null)
{
foreach (NumberingProperties id in para.ParagraphProperties.Elements<NumberingProperties>())
{
if (index - 2 < numsId.Count)
{
id.NumberingId.Val = numsId[index - 2];
}
}
}
if (para.InnerText.EndsWith("检测仪表及附件"))
{
index++;
}
}
}
}
}
}
private static void ModifyNumId(string wordPath, List<int> numsId)
{
using (WordprocessingDocument doc = WordprocessingDocument.Open(wordPath, true))
{
var paras = doc.MainDocumentPart.Document.Body.Elements<Paragraph>();
bool flag = false;
int index = 0;
if (paras != null)
{
foreach (Paragraph para in paras.ToList())
{
if (para.InnerText.StartsWith("附件：检测数据及被测设备照片"))
{
if (index == 1)
{
flag = true;
}
index++;
continue;
}
if (flag == true)
{
if (para.ParagraphProperties != null)
{
foreach (NumberingProperties id in para.ParagraphProperties.Elements<NumberingProperties>())
{
if (index - 2 < numsId.Count)
{
id.NumberingId.Val = numsId[index - 2];
}
}
}
if (para.InnerText.EndsWith("检测仪表及附件"))
{
index++;
}
}
}
}
}
}
#region 本地大报告刷序号
public static void ModifyLocalReportNumId(string wordPath, int sortWordPathListCount)
{
List<int> numsId = new List<int>();
for (int i = 0; i < sortWordPathListCount; i++)
{
int id = AddLocalReportNumberingInstance(wordPath);
if (id == -1)//id==-1，则说明未找到numId.
{
return;
}
numsId.Add(id);
}
ModifyLocalReportNumId(wordPath, numsId);
}
public static int AddLocalReportNumberingInstance(string wordPath)
{
int id = -1;
int numId = GetLocalReportNumId(wordPath);
if (numId == -1)
{
return id;
}
int abstractNumId = GetAbstractNumId(wordPath, numId.ToString());
if (abstractNumId == -1)
{
return id;
}
using (WordprocessingDocument doc = WordprocessingDocument.Open(wordPath, true))
{
Numbering numbering = doc.MainDocumentPart.NumberingDefinitionsPart.Numbering;
NumberingInstance instance = new NumberingInstance() { NumberID = numbering.Elements<NumberingInstance>().Count() + 1 };
instance.AppendChild<AbstractNumId>(new AbstractNumId() { Val = abstractNumId });
CreateLevel(instance);
numbering.AppendChild<NumberingInstance>(instance);
id = instance.NumberID;
}
return id;
}
public static int GetLocalReportNumId(string wordPath)
{
bool flag = false;
using (WordprocessingDocument doc = WordprocessingDocument.Open(wordPath, true))
{
var paras = doc.MainDocumentPart.Document.Body.Elements<Paragraph>();
if (paras != null)
{
foreach (Paragraph para in paras.ToList())
{
if (para.InnerText.StartsWith("本地大报告"))
{
flag = true;
continue;
}
if (flag)
{
if (para.ParagraphProperties != null)
{
foreach (NumberingProperties id in para.ParagraphProperties.Elements<NumberingProperties>())
{
return id.NumberingId.Val;
}
}
}
}
}
}
return -1;
}
private static void ModifyLocalReportNumId(string wordPath, List<int> numsId)
{
using (WordprocessingDocument doc = WordprocessingDocument.Open(wordPath, true))
{
var paras = doc.MainDocumentPart.Document.Body.Elements<Paragraph>();
bool flag = false;
int index = 0;
if (paras != null)
{
foreach (Paragraph para in paras.ToList())
{
if (para.InnerText.StartsWith("本地大报告"))
{
flag = true;
index = 2;
continue;
}
if (flag == true)
{
if (para.ParagraphProperties != null)
{
foreach (NumberingProperties id in para.ParagraphProperties.Elements<NumberingProperties>())
{
if (index - 2 < numsId.Count)
{
id.NumberingId.Val = numsId[index - 2];
}
}
}
}
}
}
}
}
#endregion
/// <summary>
/// 如果检测项包含整机辐射模块，则再进行编号；
/// 但非整机辐射模块也适用
/// </summary>
/// <param name="finalReport"></param>
/// <param name="fuLuNumbers"></param>
public static void ModifyFuJianIndex(string finalReport, List<string> fuLuNumbers)
{
using (WordprocessingDocument doc = WordprocessingDocument.Open(finalReport, true))
{
var paras = doc.MainDocumentPart.Document.Body.Elements<Paragraph>().Where(p => p.InnerText.StartsWith("附件"));
List<Paragraph> lstPara = new List<Paragraph>();
bool flag = false;
int count = 0;
foreach (var inst in paras)
{
if (inst.InnerText.Contains("附件：检测数据及被测设备照片"))
{
if (count == 1)
{
flag = true;
continue;
}
count++;
}
if (flag == true)
{
if (inst.InnerText.StartsWith("附件"))
{
lstPara.Add(inst);
}
}
}
int num = 0;
foreach (var inst in lstPara)
{
foreach (var item in paras)
{
if (inst == item)
{
string str = string.Empty;
if (item.InnerText.Contains(":") || item.InnerText.Contains("："))
{
//Console.WriteLine(item.InnerText);
string[] strArray = item.InnerText.Split(new Char[] { ':', '：' }, StringSplitOptions.RemoveEmptyEntries);
if (strArray.Length > 1)
{
str = strArray[1];
}
}
ModifyParagraph(item, "附件" + fuLuNumbers[num] + "：" + str);
//Console.WriteLine(num);
break;
}
}
num++;
}
}
}
public static void ModifyBaseInfo(string wordPath)
{
using (WordprocessingDocument doc = WordprocessingDocument.Open(wordPath, true))
{
var paras = doc.MainDocumentPart.Document.Body.Elements<Paragraph>();
if (paras == null)
{
return;
}
bool flag = false;
bool flag2 = true;
int index = 0;
int index2 = 0;
foreach (Paragraph para in paras.ToList())
{
if (para.InnerText.Contains("报告编号"))
{
flag2 = false;
}
if (flag2 == true)
{
if (para.InnerText.Contains("无线电发射设备"))
{
ModifyPara4(para, " 无 线 电 发 射 设 备 ", "48");
}
if (para.InnerText.Contains("检测报告"))
{
ModifyPara4(para, "检 测 报 告", "48");
}
}
if (para.InnerText.Contains("检测单位信息"))
{
if (index == 1)
{
flag = true;
}
index++;
}
if (para.InnerText.Contains("检测结果概述及检测人员签字"))
{
if (index2 == 1)
{
return;
}
index2++;
}
if (flag)
{
ModifyPara(para);
}
}
}
}
private static void ModifyPara(Paragraph para)
{
if (para.InnerText.StartsWith("电话"))
{
ModifyPara(para, "电 话");
}
if (para.InnerText.StartsWith("传真"))
{
ModifyPara(para, "传 真");
}
if (para.InnerText.StartsWith("网址"))
{
ModifyPara(para, "网 址");
}
if (para.InnerText.StartsWith("联系人"))
{
ModifyPara(para, "联 系 人");
}
if (para.InnerText.StartsWith("（检测报告专用章）"))
{
ModifyPara3(para, "（检测报告专用章）", "21");
}
if (para.InnerText.StartsWith("签发日期："))
{
ModifyPara3(para, "签发日期： 年 月 日", "24");
}
if (para.InnerText.StartsWith("审核："))
{
ModifyPara2(para, "审 核：", "28");
}
if (para.InnerText.StartsWith("批准："))
{
ModifyPara2(para, "批 准：", "28");
}
}
public static void ModifyPara4(Paragraph para, string str, string fontSize)
{
para.RemoveAllChildren<Run>();
para.Append(new Run(
new RunProperties(new FontSize() { Val = fontSize },
new RunFonts() { Hint = FontTypeHintValues.EastAsia, EastAsia = "黑体" },
new Bold()),
new Text(str)));
}
public static void ModifyPara3(Paragraph para, string str, string fontSize)
{
para.RemoveAllChildren<Run>();
if (str.Contains("检测报告专用章）"))
{
para.Append(new Run(new Text(" ") { Space = SpaceProcessingModeValues.Preserve }));
}
else
{
para.Append(new Run(new Text(" ") { Space = SpaceProcessingModeValues.Preserve }));
}
para.Append(new Run(
new RunProperties(new FontSize() { Val = fontSize },
new RunFonts() { Hint = FontTypeHintValues.EastAsia, EastAsia = "黑体" }),
new Text(str)));
}
public static void ModifyPara2(Paragraph para, string str, string fontSize)
{
para.RemoveAllChildren<Run>();
para.Append(new Run(
new RunProperties(new FontSize() { Val = fontSize },
new RunFonts() { Hint = FontTypeHintValues.EastAsia, EastAsia = "黑体" }),
new Text(str)));
}
public static void ModifyPara(Paragraph para, string str)
{
string[] strs = para.InnerText.Split(new char[] { '：', ':' });
para.RemoveAllChildren<Run>();
para.Append(
new Run(
new RunProperties(new FontSize() { Val = "24" }),
new Text(str + "：" + strs[1]))
);
}
public static void InsertParagraphAtLast(string filePath, string innerText)
{
using (WordprocessingDocument doc = WordprocessingDocument.Open(filePath, true))
{
Body b = doc.MainDocumentPart.Document.Body;
b.AppendChild<Paragraph>(CreateParagraph(innerText));
}
}
private static Paragraph CreateParagraph(string innerText)
{
return new Paragraph(
new ParagraphProperties(
new OutlineLevel() { Val = 0 },
new ParagraphMarkRunProperties(
new RunFonts() { Ascii = "黑体", HighAnsi = "黑体", EastAsia = "黑体" },
new Bold(),
new Color() { Val = "000000" },
new FontSize() { Val = "32" },
new FontSizeComplexScript() { Val = "32" })),
CreateRun(innerText)
) { RsidParagraphMarkRevision = "002D4DE0", RsidParagraphAddition = "00B87079", RsidParagraphProperties = "002D4DE0", RsidRunAdditionDefault = "00037A5D" };
}
private static Run CreateRun(string innerText)
{
return new Run(
new RunProperties(
new RunFonts() { Hint = FontTypeHintValues.EastAsia, Ascii = "黑体", HighAnsi = "黑体", EastAsia = "黑体" },
new Bold(),
new Color() { Val = "000000" },
new FontSize() { Val = "32" },
new FontSizeComplexScript() { Val = "32" }),
new Text(innerText));
}
public static void RemoveParagraph(string filePath, string keyWords, int index)
{
using (WordprocessingDocument doc = WordprocessingDocument.Open(filePath, true))
{
Body b = doc.MainDocumentPart.Document.Body;
int count = 0;
Paragraph para1 = null;
foreach (Paragraph para in b.Elements<Paragraph>())
{
if (para.InnerText.Contains(keyWords))
{
if (count == index)
{
para1 = para;
break;
}
count++;
}
}
if (para1 != null)
{
para1.Remove();
}
}
}
public static void RemoveSectionInParagraph(string filePath, string keyWords, int index)
{
using (WordprocessingDocument doc = WordprocessingDocument.Open(filePath, true))
{
int count = 0;
Paragraph para1 = null;
foreach (Paragraph para in doc.MainDocumentPart.Document.Body.Elements<Paragraph>())
{
if (para.InnerText.Contains(keyWords))
{
if (count == index)
{
para1 = para;
}
count++;
}
}
if (para1 != null)
{
IEnumerable<Run> runList = para1.Elements<Run>();
runList.Last().Remove();
}
}
}
public static void RemoveOpenXmlElement(Paragraph para)
{
List<OpenXmlElement> elementList = new List<DocumentFormat.OpenXml.OpenXmlElement>();
bool flag = false;
if (para == null)
{
return;
}
foreach (OpenXmlElement element in para.Elements())
{
if (element is PermEnd)
{
flag = false;
continue;
}
if (element is PermStart)
{
flag = true;
continue;
}
if (flag)
{
elementList.Add(element);
}
}
foreach (OpenXmlElement element in elementList)
{
if (element != null)
{
element.Remove();
}
}
}
public static void InsertRunAfterPermStart(Paragraph para, params string[] innerTxtList)
{
List<PermStart> permStartList = new List<PermStart>();
if (para == null)
{
return;
}
RemoveOpenXmlElement(para);
foreach (PermStart startElement in para.Elements<PermStart>())
{
if (startElement != null)
{
permStartList.Add(startElement);
}
}
int i = 0;
foreach (PermStart permStart in permStartList)
{
if (i < innerTxtList.Length)
{
permStart.InsertAfterSelf<Run>(new Run(new Text(innerTxtList[i])));
}
i++;
}
}
public static List<string> GetRunAfterPermStart(Paragraph para)
{
List<string> list = new List<string>();
if (para == null)
{
return null;
}
bool flag = false;
List<Run> runList = new List<Run>();
foreach (OpenXmlElement startElement in para.Elements<OpenXmlElement>())
{
if (startElement == null)
{
continue;
}
if (startElement is PermEnd)
{
string str = string.Empty;
foreach (Run run in runList)
{
str += run.InnerText;
}
list.Add(str);
flag = false;
}
if (flag && (startElement is Run))
{
runList.Add((Run)startElement);
}
if (startElement is PermStart)
{
runList.Clear();
flag = true;
}
}
return list;
}
/// <summary>
/// 对齐方式
/// </summary>
/// <param name="prop"></param>
/// <param name="enumVal"></param>
public static void JustificationWay(ParagraphProperties prop, JustificationValues enumVal)
{
if (prop != null)
{
var justifications = prop.Elements<Justification>();
if (justifications != null)
{
Justification just = justifications.FirstOrDefault();
if (just != null)
{
just.Val = enumVal;
}
}
else
{
Justification just = new Justification() { Val = enumVal };
prop.Append(just);
}
}
}
/// <summary>
/// 得到startVals->结尾 的OpenXmlElement
/// </summary>
/// <param name="wordPath"></param>
/// <param name="startVals">开始关键字</param>
///<param name="startNum">第几个startVals，从0开始</param>
/// <param name="way">0：包含startVals； 1：不包含startVals</param>
/// <param name="copyOrRemove">0：返回拷贝的数据； 1：返回原数据</param>
/// <returns></returns>
public static List<OpenXmlElement> FindOpenXmlElement(string wordPath, string startVals, int startNum, int way, int copyOrRemove)
{
List<OpenXmlElement> elementList = new List<OpenXmlElement>();
using (WordprocessingDocument doc = WordprocessingDocument.Open(wordPath, true))
{
elementList = FindOpenXmlElement(startVals, startNum, way, copyOrRemove, doc);
}
return elementList;
}
public static List<OpenXmlElement> FindOpenXmlElement(string startVals, int startNum, int way, int copyOrRemove, WordprocessingDocument doc)
{
List<OpenXmlElement> elementList = new List<OpenXmlElement>();
Body b = doc.MainDocumentPart.Document.Body;
bool flag = false;
int count = 0;
foreach (OpenXmlElement element in b.Elements<OpenXmlElement>())
{
if (element.InnerText.EndsWith(startVals))
{
if (count == startNum)
{
flag = true;
if (way == 1)
{
count++;
continue;
}
}
count++;
}
if (element is SectionProperties)
{
continue;
}
if (flag)
{
if (copyOrRemove == 0)
{
elementList.Add(element.CloneNode(true));
}
else if (copyOrRemove == 1)
{
elementList.Add(element);
}
}
}
return elementList;
}
/// <summary>
/// 得到startVals->endVals之间 的OpenXmlElement
/// </summary>
/// <param name="wordPath"></param>
/// <param name="startVals">开始关键字</param>
/// <param name="startNum">第几个startVals，从0开始</param>
/// <param name="endVals">结束关键字</param>
/// <param name="endNum">第几个endVals，从0开始</param>
/// <param name="way">0：包含startVals，包含endVals； 1：不包含startVals，不包含endVals;2:只包含startVals；3:只包含endVals</param>
/// <param name="copyOrRemove">0：返回拷贝的数据； 1：返回原数据</param>
/// <returns></returns>
public static List<OpenXmlElement> FindOpenXmlElement(string wordPath, string startVals, int startNum, string endVals, int endNum, int way, int copyOrRemove)
{
List<OpenXmlElement> elementList = new List<OpenXmlElement>();
using (WordprocessingDocument doc = WordprocessingDocument.Open(wordPath, true))
{
elementList = FindOpenXmlElement(startVals, startNum, endVals, endNum, way, copyOrRemove, doc);
}
return elementList;
}
public static List<OpenXmlElement> FindOpenXmlElement(string startVals, int startNum, string endVals, int endNum, int way, int copyOrRemove, WordprocessingDocument doc)
{
List<OpenXmlElement> elementList = new List<OpenXmlElement>();
Body b = doc.MainDocumentPart.Document.Body;
bool flag = false;
int startCount = 0;
int endCount = 0;
foreach (OpenXmlElement element in b.Elements<OpenXmlElement>())
{
switch (way)
{
case 0:
Step1(startVals, startNum, ref flag, ref startCount, element);
Step2(elementList, flag, copyOrRemove, element);
Step3(endVals, endNum, ref flag, ref endCount, element);
break;
case 1:
Step3(endVals, endNum, ref flag, ref endCount, element);
Step2(elementList, flag, copyOrRemove, element);
Step1(startVals, startNum, ref flag, ref startCount, element);
break;
case 2:
Step3(endVals, endNum, ref flag, ref endCount, element);
Step1(startVals, startNum, ref flag, ref startCount, element);
Step2(elementList, flag, copyOrRemove, element);
break;
case 3:
Step2(elementList, flag, copyOrRemove, element);
Step1(startVals, startNum, ref flag, ref startCount, element);
Step3(endVals, endNum, ref flag, ref endCount, element);
break;
}
}
return elementList;
}
private static void Step3(string endVals, int endNum, ref bool flag, ref int endCount, OpenXmlElement element)
{
if (element.InnerText.EndsWith(endVals))
{
if (endCount == endNum)
{
flag = false;
}
endCount++;
}
}
private static void Step2(List<OpenXmlElement> elementList, bool flag, int copyOrRemove, OpenXmlElement element)
{
if (flag)
{
if (copyOrRemove == 0)
{
elementList.Add(element.CloneNode(true));
}
else if (copyOrRemove == 1)
{
elementList.Add(element);
}
}
}
private static void Step1(string startVals, int startNum, ref bool flag, ref int startCount, OpenXmlElement element)
{
if (element.InnerText.EndsWith(startVals))
{
if (startCount == startNum)
{
flag = true;
}
startCount++;
}
}
/// <summary>
/// srcPath中的openXmlList复制到dstPath中，需要把srcPath的ImagePart信息copy到dstPath中，重新关联id关系
/// 修改图片关联Id
/// </summary>
/// <param name="srcPath"></param>
/// <param name="dstPath"></param>
/// <param name="srcOpenXmlElementList">srcPath中的OpenXmlElementList</param>
public static void ModifyAssociatedIdOfPicture(string srcPath, string dstPath, List<OpenXmlElement> srcOpenXmlElementList)
{
Dictionary<string, string> newAndOldId = new Dictionary<string, string>();
using (WordprocessingDocument doc = WordprocessingDocument.Open(dstPath, true))
{
using (WordprocessingDocument doc2 = WordprocessingDocument.Open(srcPath, true))
{
foreach (ImagePart inst in doc2.MainDocumentPart.ImageParts)
{
ImagePart imagePart = doc.MainDocumentPart.AddPart<ImagePart>(inst);
newAndOldId.Add(doc2.MainDocumentPart.GetIdOfPart(inst), doc.MainDocumentPart.GetIdOfPart(imagePart));
}
}
foreach (OpenXmlElement element in srcOpenXmlElementList)
{
foreach (AA.Blip blip in element.Descendants<AA.Blip>())
{
blip.Embed = newAndOldId[blip.Embed];
}
foreach (V.ImageData imageData in element.Descendants<V.ImageData>())
{
imageData.RelationshipId = newAndOldId[imageData.RelationshipId];
}
}
}
}
#region Insert SectionBreak
/// <summary>
///
/// </summary>
/// <param name="fileName"></param>
/// <param name="innerTxt"></param>
/// <param name="condition">0:StartsWith,1:Contains,2:EndsWith</param>
public static void InsertSectionBreakByParagraphInnerTxt(string fileName, string innerTxt, int condition)
{
using (WordprocessingDocument wDoc = WordprocessingDocument.Open(fileName, true))
{
Body b = wDoc.MainDocumentPart.Document.Body;
var pFirst = OpenXmlUtil.FindParaByInnerTxt(wDoc, innerTxt, condition).FirstOrDefault();
if (pFirst == null)
{
return;
}
//In order to position the section break within a paragraph, there
//actually needs to be a new paragraph that follows the section break.
//Make a copy of the first paragraph, then break it into two parts (paras).
Paragraph pNew1 = (Paragraph)pFirst.CloneNode(true);
Paragraph pNew2 = new Paragraph();
pFirst.InsertAfterSelf(pNew2);
//First para contains first run of original
var runs = pNew1.Elements<Run>();
foreach (var inst in runs)
{
pNew2.Append(inst.CloneNode(true));
}
//Add the section break to the first paragraph.
ParagraphProperties pProps = pNew1.Elements<ParagraphProperties>().FirstOrDefault(); //old ParagraphProperties;
//ParagraphProperties pPropsCloneNode = (ParagraphProperties)pProps.CloneNode(true); //CloneNode old ParagraphProperties;
ParagraphProperties pPropsCloneNode = GenerateParagraphProperties();
if (pPropsCloneNode != null)
{
pNew2.InsertAt(pPropsCloneNode, 0);
}
//Second paragraph contains all but first run of original
foreach (var inst in runs)
{
inst.RemoveAllChildren();
inst.Remove();
}
//Remove the original paragraph at the end.
pFirst.RemoveAllChildren();
pFirst.Remove();
}
}
public static void RemoveFooterAllChild(string wordPath)
{
using (WordprocessingDocument doc = WordprocessingDocument.Open(wordPath, true))
{
if (doc.MainDocumentPart.FooterParts != null)
{
List<Footer> footerLst = new List<Footer>();
foreach (FooterPart footerPart in doc.MainDocumentPart.FooterParts)
{
footerLst.Add(footerPart.Footer);
}
foreach (Footer footer in footerLst)
{
footer.RemoveAllChildren();
}
}
}
}
public static ParagraphProperties GenerateParagraphProperties()
{
ParagraphProperties paragraphProperties1 = new ParagraphProperties();
ParagraphMarkRunProperties paragraphMarkRunProperties1 = new ParagraphMarkRunProperties();
RunFonts runFonts1 = new RunFonts() { Ascii = "Arial", HighAnsi = "Arial", ComplexScript = "Arial" };
Color color1 = new Color() { Val = "000000" };
FontSize fontSize1 = new FontSize() { Val = "24" };
FontSizeComplexScript fontSizeComplexScript1 = new FontSizeComplexScript() { Val = "24" };
paragraphMarkRunProperties1.Append(runFonts1);
paragraphMarkRunProperties1.Append(color1);
paragraphMarkRunProperties1.Append(fontSize1);
paragraphMarkRunProperties1.Append(fontSizeComplexScript1);
SectionProperties sectionProperties1 = new SectionProperties() { RsidR = "00E04B20", RsidSect = "00D46C38" };
//HeaderReference headerReference1 = new HeaderReference() { Type = HeaderFooterValues.Default, Id = "rId9" };
PageSize pageSize1 = new PageSize() { Width = (UInt32Value)11906U, Height = (UInt32Value)16838U };
PageMargin pageMargin1 = new PageMargin() { Top = 1644, Right = (UInt32Value)1797U, Bottom = 1440, Left = (UInt32Value)1622U, Header = (UInt32Value)851U, Footer = (UInt32Value)992U, Gutter = (UInt32Value)0U };
PageNumberType pageNumberType1 = new PageNumberType() { Start = 1 };
Columns columns1 = new Columns() { Space = "720" };
DocGrid docGrid1 = new DocGrid() { Type = DocGridValues.Lines, LinePitch = 312 };
//sectionProperties1.Append(headerReference1);
sectionProperties1.Append(pageSize1);
sectionProperties1.Append(pageMargin1);
sectionProperties1.Append(pageNumberType1);
sectionProperties1.Append(columns1);
sectionProperties1.Append(docGrid1);
paragraphProperties1.Append(paragraphMarkRunProperties1);
paragraphProperties1.Append(sectionProperties1);
return paragraphProperties1;
}
#endregion
[DllImport("kernel32.dll")]
public static extern IntPtr _lopen(string lpPathName, int iReadWrite);
[DllImport("kernel32.dll")]
public static extern bool CloseHandle(IntPtr hObject);
public const int OF_READWRITE = 2;
public const int OF_SHARE_DENY_NONE = 0x40;
public static readonly IntPtr HFILE_ERROR = new IntPtr(-1);
/// <summary>
/// 判断文件是否被占用
/// </summary>
/// <param name="filePath"></param>
/// <returns></returns>
public static bool IsInUse(string filePath)
{
IntPtr vHandle = _lopen(filePath, OF_READWRITE | OF_SHARE_DENY_NONE);
if (vHandle == HFILE_ERROR)
{
return true;
}
CloseHandle(vHandle);
return false;
}
public static void RenameLEXuHao(string mergeSingeMxa20Paht)
{
using (WordprocessingDocument doc = WordprocessingDocument.Open(mergeSingeMxa20Paht, true))
{
Body body = doc.MainDocumentPart.Document.Body;
int num = 0;
bool isLe = false;
string sencondTitleStr = string.Empty;
foreach (var paragraph in body.Elements<DocumentFormat.OpenXml.Wordprocessing.Paragraph>())
{
var oil = paragraph.Descendants<OutlineLevel>().FirstOrDefault();
if (oil == null)
{
continue;
}
if (paragraph.InnerText.Contains("检测条件"))
{
num = 0;
isLe = false;
continue;
}
if (paragraph.InnerText.Contains("BR部分检测数据"))
{
num++;
isLe = false;
continue;
}
if (paragraph.InnerText.Contains("EDR部分检测数据"))
{
num++;
isLe = false;
continue;
}
if (paragraph.InnerText.Contains("LE部分检测数据"))
{
if (num != 0)
{
isLe = true;
string xuHaoStr = "5." + ++num;
sencondTitleStr = "5." + num + ".";
string titleName = xuHaoStr + " LE部分检测数据";
OpenXmlUtil.ModifyParagraph(paragraph, titleName);
continue;
}
}
if (isLe)
{
var contentStr = paragraph.InnerText.Replace("5.1.", sencondTitleStr);
OpenXmlUtil.ModifyParagraph(paragraph, contentStr);
}
}
}
}
public static void InsertTestDataMxa20(string mergeSingeMxa20Paht, List<List<OpenXmlElement>> mergeSingeMxaOpenXmlElementLists)
{
using (WordprocessingDocument doc = WordprocessingDocument.Open(mergeSingeMxa20Paht, true))
{
Body body = doc.MainDocumentPart.Document.Body;
List<OpenXmlElement> openXmlElementList = body.Elements<OpenXmlElement>().Where(p => p.InnerText.Contains("检测仪表及附件")).ToList();
for (int i = 0; i < openXmlElementList.Count; i++)
{
if (i < mergeSingeMxaOpenXmlElementLists.Count)
{
foreach (var openXmlElement in mergeSingeMxaOpenXmlElementLists[i])
{
var newOpenXmlElement = openXmlElement.CloneNode(true);
openXmlElementList[i].InsertBeforeSelf(newOpenXmlElement);
}
}
}
}
}
public static void GenMergeSingleMxa40TestData(string mergeSingeMxa40Paht, List<List<OpenXmlElement>> mergeSingeMxaOpenXmlElementLists)
{
List<OpenXmlElement> mergeSingeMxaOpenXmlElementList = new List<OpenXmlElement>();
bool isFlag = false;
using (WordprocessingDocument doc = WordprocessingDocument.Open(mergeSingeMxa40Paht, true))
{
Body body = doc.MainDocumentPart.Document.Body;
foreach (var openXmlElement in body.Elements<OpenXmlElement>())
{
if (openXmlElement.InnerText.Contains("LE部分检测数据"))
{
mergeSingeMxaOpenXmlElementList = new List<OpenXmlElement>();
isFlag = true;
}
if (openXmlElement.InnerText.Contains("检测仪表及附件"))
{
isFlag = false;
mergeSingeMxaOpenXmlElementLists.Add(mergeSingeMxaOpenXmlElementList);
continue;
}
if (isFlag)
{
mergeSingeMxaOpenXmlElementList.Add(openXmlElement);
}
}
}
}
public static List<List<OpenXmlElement>> RangList(string mergeSingeMxa40Path, string startContentStr, string endContentStr)
{
List<List<OpenXmlElement>> openXmlElementForJianCeList = new List<List<OpenXmlElement>>();
using (WordprocessingDocument doc = WordprocessingDocument.Open(mergeSingeMxa40Path, true))
{
Body body = doc.MainDocumentPart.Document.Body;
bool isFlag = false;
List<OpenXmlElement> openXmlElementList = new List<OpenXmlElement>();
foreach (var openXmlElement in body.Elements<OpenXmlElement>())
{
if (openXmlElement.InnerText.Contains(startContentStr))
{
isFlag = true;
openXmlElementList = new List<OpenXmlElement>();
continue;
}
if (openXmlElement.InnerText.Contains(endContentStr))
{
isFlag = false;
openXmlElementForJianCeList.Add(openXmlElementList);
continue;
}
if (isFlag)
{
openXmlElementList.Add(openXmlElement);
}
}
}
return openXmlElementForJianCeList;
}
public static void ModefyPicNum(string biaoTiNum, string wordPath)
{
using (WordprocessingDocument doc = WordprocessingDocument.Open(wordPath, true))
{
ModefyPicNum(biaoTiNum, doc);
}
}
public static void ModefyPicNum(string biaoTiNum, WordprocessingDocument doc)
{
Body body = doc.MainDocumentPart.Document.Body;
List<Paragraph> openXmlParagraphList = new List<Paragraph>();
openXmlParagraphList = body.Elements<Paragraph>().Where(p => (p.InnerText.Contains("图") && p.InnerText.Contains("-")) && !p.InnerText.Contains("图5-")).ToList();
for (int i = 0; i < openXmlParagraphList.Count; i++)
{
OpenXmlUtil.ModifyParagraph(openXmlParagraphList[i], "图" + biaoTiNum + "-" + (i + 1));
}
}
/// <summary>
/// 修改标题的缩进，左对齐Left=0
/// </summary>
/// <param name="path"></param>
public static void SetIndentationInNumParagraph(string path)
{
using (WordprocessingDocument doc = WordprocessingDocument.Open(path, true))
{
var body = doc.MainDocumentPart.Document.Body;
List<Paragraph> allNumPara = OpenXmlUtil.FindAllPara(doc).Where(p => p.Descendants<NumberingProperties>().Count() > 0).ToList();
for (int i = 0; i < allNumPara.Count; i++)
{
var indents = allNumPara[i].Descendants<Indentation>();
foreach (var indent in indents)
{
indent.FirstLineChars = new DocumentFormat.OpenXml.Int32Value(0);
indent.Left = new DocumentFormat.OpenXml.StringValue("0");
indent.FirstLine = new DocumentFormat.OpenXml.StringValue("0");
indent.Hanging = null;
}
}
}
}
}
}
此方法需要引用DocumentFormat.OpenXml; 这个大家可以在网上一下。
308
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
