public virtual void ReplaceText(string searchValue,
string newValue,
bool trackChanges = false,
RegexOptions options = RegexOptions.None,
Formatting newFormatting = null,
Formatting matchFormatting = null,
MatchFormattingOptions fo = MatchFormattingOptions.SubsetMatch,
bool escapeRegEx = true,
bool useRegExSubstitutions = false,
bool removeEmptyParagraph = true)
{
if (string.IsNullOrEmpty(searchValue))
{
throw new ArgumentException("searchValue cannot be null or empty.", "searchValue");
}
if (newValue == null)
{
throw new ArgumentException("newValue cannot be null.", "newValue");
}
foreach (var p in this.Paragraphs)
{
p.ReplaceText(searchValue, newValue, trackChanges, options, newFormatting, matchFormatting, fo, escapeRegEx, useRegExSubstitutions, removeEmptyParagraph);
}
}
public virtual void ReplaceText(string searchValue,
string newValue,
bool trackChanges = false,
RegexOptions options = RegexOptions.None,
Formatting newFormatting = null,
Formatting matchFormatting = null,
MatchFormattingOptions fo = MatchFormattingOptions.SubsetMatch,
bool escapeRegEx = true,
bool useRegExSubstitutions = false,
bool removeEmptyParagraph = true)
{
if (string.IsNullOrEmpty(searchValue))
{
throw new ArgumentException("searchValue cannot be null or empty.", "searchValue");
}
if (newValue == null)
{
throw new ArgumentException("newValue cannot be null.", "newValue");
}
// ReplaceText in Headers of the document.
var headerList = new List <Header>()
{
this.Document.Headers.First, this.Document.Headers.Even, this.Document.Headers.Odd
};
foreach (Header h in headerList)
{
if (h != null)
{
foreach (Paragraph p in h.Paragraphs)
{
p.ReplaceText(searchValue, newValue, trackChanges, options, newFormatting, matchFormatting, fo, escapeRegEx, useRegExSubstitutions, removeEmptyParagraph);
}
}
}
// ReplaceText int main body of document.
foreach (Paragraph p in this.Paragraphs)
{
p.ReplaceText(searchValue, newValue, trackChanges, options, newFormatting, matchFormatting, fo, escapeRegEx, useRegExSubstitutions, removeEmptyParagraph);
}
// ReplaceText in Footers of the document.
var footerList = new List <Footer> {
this.Document.Footers.First, this.Document.Footers.Even, this.Document.Footers.Odd
};
foreach (Footer f in footerList)
{
if (f != null)
{
foreach (Paragraph p in f.Paragraphs)
{
p.ReplaceText(searchValue, newValue, trackChanges, options, newFormatting, matchFormatting, fo, escapeRegEx, useRegExSubstitutions, removeEmptyParagraph);
}
}
}
}
public int RemoveTextInGivenFormat( Formatting formattingToMatch, MatchFormattingOptions formattingOptions = MatchFormattingOptions.SubsetMatch )
{
var count = 0;
foreach( var element in Xml.Elements() )
count += RecursiveRemoveText( element, formattingToMatch, formattingOptions );
return count;
}
public int RemoveTextInGivenFormat(Formatting matchFormatting, MatchFormattingOptions fo = MatchFormattingOptions.SubsetMatch)
{
int num = 0;
foreach (XElement item in base.Xml.Elements())
{
num += RemoveTextWithFormatRecursive(item, matchFormatting, fo);
}
return(num);
}
/// <summary>
/// Removes all items with required formatting
/// </summary>
/// <returns>Numer of texts removed</returns>
public int RemoveTextInGivenFormat(Formatting matchFormatting, MatchFormattingOptions fo = MatchFormattingOptions.SubsetMatch)
{
var deletedCount = 0;
foreach (var x in Xml.Elements())
{
deletedCount += RemoveTextWithFormatRecursive(x, matchFormatting, fo);
}
return(deletedCount);
}
/// <summary>
/// Checks whether 'toCheck' has all children that 'desired' has and values of 'val' attributes are the same
/// </summary>
/// <param name="desired"></param>
/// <param name="toCheck"></param>
/// <param name="fo">Matching options whether check if desired attributes are inder a, or a has exactly and only these attributes as b has.</param>
/// <returns></returns>
internal static bool ContainsEveryChildOf(XElement desired, XElement toCheck, MatchFormattingOptions fo)
{
foreach (XElement e in desired.Elements())
{
// If a formatting property has the same name and 'val' attribute's value, its considered to be equivalent.
if (!toCheck.Elements(e.Name).Where(bElement => bElement.GetAttribute(XName.Get("val", DocX.w.NamespaceName)) == e.GetAttribute(XName.Get("val", DocX.w.NamespaceName))).Any())
return false;
}
// If the formatting has to be exact, no additionaly formatting must exist.
if (fo == MatchFormattingOptions.ExactMatch)
return desired.Elements().Count() == toCheck.Elements().Count();
return true;
}
/// <summary>
///
/// </summary>
/// <param name="searchValue">The value to find.</param>
/// <param name="regexMatchHandler">A Func who accepts the matching regex search group value and passes it to this to return the replacement string.</param>
/// <param name="trackChanges">Enable or disable the track changes.</param>
/// <param name="options">The Regex options.</param>
/// <param name="newFormatting"></param>
/// <param name="matchFormatting"></param>
/// <param name="fo"></param>
/// <param name="removeEmptyParagraph">Remove empty paragraph</param>
public virtual void ReplaceText(string searchValue,
Func <string, string> regexMatchHandler,
bool trackChanges = false,
RegexOptions options = RegexOptions.None,
Formatting newFormatting = null,
Formatting matchFormatting = null,
MatchFormattingOptions fo = MatchFormattingOptions.SubsetMatch,
bool removeEmptyParagraph = true)
{
if (string.IsNullOrEmpty(searchValue))
{
throw new ArgumentException("searchValue cannot be null or empty.", "searchValue");
}
if (regexMatchHandler == null)
{
throw new ArgumentException("regexMatchHandler cannot be null", "regexMatchHandler");
}
// Replace text in headers and footers of the Document.
foreach (var section in this.Document.Sections)
{
var headersFootersList = new List <IParagraphContainer>()
{
section.Headers.First,
section.Headers.Even,
section.Headers.Odd,
section.Footers.First,
section.Footers.Even,
section.Footers.Odd,
};
foreach (var hf in headersFootersList)
{
if (hf != null)
{
foreach (var p in hf.Paragraphs)
{
p.ReplaceText(searchValue, regexMatchHandler, trackChanges, options, newFormatting, matchFormatting, fo, removeEmptyParagraph);
}
}
}
}
foreach (var p in this.Paragraphs)
{
p.ReplaceText(searchValue, regexMatchHandler, trackChanges, options, newFormatting, matchFormatting, fo, removeEmptyParagraph);
}
}
/// <summary>
///
/// </summary>
/// <param name="searchValue">The value to find.</param>
/// <param name="regexMatchHandler">A Func who accepts the matching regex search group value and passes it to this to return the replacement string.</param>
/// <param name="trackChanges">Enable or disable the track changes.</param>
/// <param name="options">The Regex options.</param>
/// <param name="newFormatting"></param>
/// <param name="matchFormatting"></param>
/// <param name="fo"></param>
/// <param name="removeEmptyParagraph">Remove empty paragraph</param>
public virtual void ReplaceText(string searchValue,
Func <string, string> regexMatchHandler,
bool trackChanges = false,
RegexOptions options = RegexOptions.None,
Formatting newFormatting = null,
Formatting matchFormatting = null,
MatchFormattingOptions fo = MatchFormattingOptions.SubsetMatch,
bool removeEmptyParagraph = true)
{
if (string.IsNullOrEmpty(searchValue))
{
throw new ArgumentException("searchValue cannot be null or empty.", "searchValue");
}
if (regexMatchHandler == null)
{
throw new ArgumentException("regexMatchHandler cannot be null", "regexMatchHandler");
}
foreach (var p in this.Paragraphs)
{
p.ReplaceText(searchValue, regexMatchHandler, trackChanges, options, newFormatting, matchFormatting, fo, removeEmptyParagraph);
}
}
public virtual void ReplaceTextWithObject(string searchValue,
DocumentElement objectToAdd,
bool trackChanges = false,
RegexOptions options = RegexOptions.None,
Formatting matchFormatting = null,
MatchFormattingOptions fo = MatchFormattingOptions.SubsetMatch,
bool escapeRegEx = true,
bool removeEmptyParagraph = true)
{
if (string.IsNullOrEmpty(searchValue))
{
throw new ArgumentException("searchValue cannot be null or empty.", "searchValue");
}
if (objectToAdd == null)
{
throw new ArgumentException("objectToAdd cannot be null.", "objectToAdd");
}
// ReplaceText in the container
foreach (Paragraph p in this.Paragraphs)
{
p.ReplaceTextWithObject(searchValue, objectToAdd, trackChanges, options, matchFormatting, fo, escapeRegEx, removeEmptyParagraph);
}
}
/// <summary>
///
/// </summary>
/// <param name="searchValue">Value to find</param>
/// <param name="regexMatchHandler">A Func that accepts the matching regex search group value and passes it to this to return the replacement string</param>
/// <param name="trackChanges">Enable trackchanges</param>
/// <param name="options">Regex options</param>
/// <param name="newFormatting"></param>
/// <param name="matchFormatting"></param>
/// <param name="formattingOptions"></param>
public virtual void ReplaceText(string searchValue, Func<string,string> regexMatchHandler, bool trackChanges = false, RegexOptions options = RegexOptions.None, Formatting newFormatting = null, Formatting matchFormatting = null, MatchFormattingOptions formattingOptions = MatchFormattingOptions.SubsetMatch)
{
if (string.IsNullOrEmpty(searchValue))
throw new ArgumentException("oldValue cannot be null or empty", "searchValue");
if (regexMatchHandler == null)
throw new ArgumentException("regexMatchHandler cannot be null", "regexMatchHandler");
// ReplaceText in Headers/Footers of the document.
var containerList = new List<IParagraphContainer> {
Document.Headers.first, Document.Headers.even, Document.Headers.odd,
Document.Footers.first, Document.Footers.even, Document.Footers.odd };
foreach (var container in containerList)
if (container != null)
foreach (var paragraph in container.Paragraphs)
paragraph.ReplaceText(searchValue, regexMatchHandler, trackChanges, options, newFormatting, matchFormatting, formattingOptions);
// ReplaceText int main body of document.
foreach (var paragraph in Paragraphs)
paragraph.ReplaceText(searchValue, regexMatchHandler, trackChanges, options, newFormatting, matchFormatting, formattingOptions);
}
public virtual void ReplaceText(string searchValue, string newValue, bool trackChanges = false, RegexOptions options = RegexOptions.None, Formatting newFormatting = null, Formatting matchFormatting = null, MatchFormattingOptions formattingOptions = MatchFormattingOptions.SubsetMatch, bool escapeRegEx = true, bool useRegExSubstitutions = false)
{
if (string.IsNullOrEmpty(searchValue))
throw new ArgumentException("oldValue cannot be null or empty", "searchValue");
if (newValue == null)
throw new ArgumentException("newValue cannot be null or empty", "newValue");
// ReplaceText in Headers of the document.
var headerList = new List<Header> { Document.Headers.first, Document.Headers.even, Document.Headers.odd };
foreach (var header in headerList)
if (header != null)
foreach (var paragraph in header.Paragraphs)
paragraph.ReplaceText(searchValue, newValue, trackChanges, options, newFormatting, matchFormatting, formattingOptions, escapeRegEx, useRegExSubstitutions);
// ReplaceText int main body of document.
foreach (var paragraph in Paragraphs)
paragraph.ReplaceText(searchValue, newValue, trackChanges, options, newFormatting, matchFormatting, formattingOptions, escapeRegEx, useRegExSubstitutions);
// ReplaceText in Footers of the document.
var footerList = new List<Footer> { Document.Footers.first, Document.Footers.even, Document.Footers.odd };
foreach (var footer in footerList)
if (footer != null)
foreach (var paragraph in footer.Paragraphs)
paragraph.ReplaceText(searchValue, newValue, trackChanges, options, newFormatting, matchFormatting, formattingOptions, escapeRegEx, useRegExSubstitutions);
}
/// <summary>
/// Removes all items with required formatting
/// </summary>
/// <returns>Numer of texts removed</returns>
public int RemoveTextInGivenFormat(Formatting matchFormatting, MatchFormattingOptions fo = MatchFormattingOptions.SubsetMatch)
{
var deletedCount = 0;
foreach (var x in Xml.Elements())
{
deletedCount += RemoveTextWithFormatRecursive(x, matchFormatting, fo);
}
return deletedCount;
}
internal static bool ContainsEveryChildOf(XElement elementWanted, XElement elementToValidate, MatchFormattingOptions formattingOptions)
{
foreach (XElement subElement in elementWanted.Elements())
{
if (!elementToValidate.Elements(subElement.Name).Where(bElement => bElement.GetAttribute(XName.Get("val", DocX.w.NamespaceName)) == subElement.GetAttribute(XName.Get("val", DocX.w.NamespaceName))).Any())
{
return(false);
}
}
if (formattingOptions == MatchFormattingOptions.ExactMatch)
{
return(elementWanted.Elements().Count() == elementToValidate.Elements().Count());
}
return(true);
}
internal bool ContainsEveryChildOf(XElement a, XElement b, MatchFormattingOptions fo)
{
foreach (XElement e in a.Elements())
{
// If a formatting property has the same name and value, its considered to be equivalent.
if (!b.Elements(e.Name).Where(bElement => bElement.Value == e.Value).Any())
return false;
}
// If the formatting has to be exact, no additionaly formatting must exist.
if (fo == MatchFormattingOptions.ExactMatch)
return a.Elements().Count() == b.Elements().Count();
return true;
}
/// <summary>
/// Replaces all occurrences of a specified System.String in this instance, with another specified System.String.
/// </summary>
/// <example>
/// <code>
/// // Load a document using a relative filename.
/// using (DocX document = DocX.Load(@"C:\Example\Test.docx"))
/// {
/// // The formatting to match.
/// Formatting matchFormatting = new Formatting();
/// matchFormatting.Size = 10;
/// matchFormatting.Italic = true;
/// matchFormatting.FontFamily = new FontFamily("Times New Roman");
///
/// // The formatting to apply to the inserted text.
/// Formatting newFormatting = new Formatting();
/// newFormatting.Size = 22;
/// newFormatting.UnderlineStyle = UnderlineStyle.dotted;
/// newFormatting.Bold = true;
///
/// // Iterate through the paragraphs in this document.
/// foreach (Paragraph p in document.Paragraphs)
/// {
/// /*
/// * Replace all instances of the string "wrong" with the string "right" and ignore case.
/// * Each inserted instance of "wrong" should use the Formatting newFormatting.
/// * Only replace an instance of "wrong" if it is Size 10, Italic and Times New Roman.
/// * SubsetMatch means that the formatting must contain all elements of the match formatting,
/// * but it can also contain additional formatting for example Color, UnderlineStyle, etc.
/// * ExactMatch means it must not contain additional formatting.
/// */
/// p.ReplaceText("wrong", "right", false, RegexOptions.IgnoreCase, newFormatting, matchFormatting, MatchFormattingOptions.SubsetMatch);
/// }
///
/// // Save all changes made to this document.
/// document.Save();
/// }// Release this document from memory.
/// </code>
/// </example>
/// <seealso cref="Paragraph.RemoveText(int, int, bool)"/>
/// <seealso cref="Paragraph.RemoveText(int, bool)"/>
/// <seealso cref="Paragraph.InsertText(string, bool)"/>
/// <seealso cref="Paragraph.InsertText(int, string, bool)"/>
/// <seealso cref="Paragraph.InsertText(int, string, bool, Formatting)"/>
/// <seealso cref="Paragraph.InsertText(string, bool, Formatting)"/>
/// <param name="newValue">A System.String to replace all occurances of oldValue.</param>
/// <param name="oldValue">A System.String to be replaced.</param>
/// <param name="options">A bitwise OR combination of RegexOption enumeration options.</param>
/// <param name="trackChanges">Track changes</param>
/// <param name="newFormatting">The formatting to apply to the text being inserted.</param>
/// <param name="matchFormatting">The formatting that the text must match in order to be replaced.</param>
/// <param name="fo">How should formatting be matched?</param>
public void ReplaceText(string oldValue, string newValue, bool trackChanges = false, RegexOptions options = RegexOptions.None, Formatting newFormatting = null, Formatting matchFormatting = null, MatchFormattingOptions fo = MatchFormattingOptions.SubsetMatch)
{
MatchCollection mc = Regex.Matches(this.Text, Regex.Escape(oldValue), options);
// Loop through the matches in reverse order
foreach (Match m in mc.Cast<Match>().Reverse())
{
// Assume the formatting matches until proven otherwise.
bool formattingMatch = true;
// Does the user want to match formatting?
if (matchFormatting != null)
{
// The number of characters processed so far
int processed = 0;
do
{
// Get the next run effected
Run run = GetFirstRunEffectedByEdit(m.Index + processed);
// Get this runs properties
XElement rPr = run.Xml.Element(XName.Get("rPr", DocX.w.NamespaceName));
if (rPr == null)
rPr = new Formatting().Xml;
/*
* Make sure that every formatting element in f.xml is also in this run,
* if this is not true, then their formatting does not match.
*/
if (!ContainsEveryChildOf(matchFormatting.Xml, rPr, fo))
{
formattingMatch = false;
break;
}
// We have processed some characters, so update the counter.
processed += run.Value.Length;
} while (processed < m.Length);
}
// If the formatting matches, do the replace.
if (formattingMatch)
{
InsertText(m.Index + oldValue.Length, newValue, trackChanges, newFormatting);
RemoveText(m.Index, m.Length, trackChanges);
}
}
}
/// <summary>
/// Checks whether 'toCheck' has all children that 'desired' has and values of 'val' attributes are the same
/// </summary>
/// <param name="desired"></param>
/// <param name="toCheck"></param>
/// <param name="fo">Matching options whether check if desired attributes are inder a, or a has exactly and only these attributes as b has.</param>
/// <returns></returns>
internal static bool ContainsEveryChildOf(XElement desired, XElement toCheck, MatchFormattingOptions fo)
{
foreach (XElement e in desired.Elements())
{
// If a formatting property has the same name and 'val' attribute's value, its considered to be equivalent.
if (!toCheck.Elements(e.Name).Where(bElement => bElement.GetAttribute(XName.Get("val", DocX.w.NamespaceName)) == e.GetAttribute(XName.Get("val", DocX.w.NamespaceName))).Any())
{
return(false);
}
}
// If the formatting has to be exact, no additionaly formatting must exist.
if (fo == MatchFormattingOptions.ExactMatch)
{
return(desired.Elements().Count() == toCheck.Elements().Count());
}
return(true);
}
public virtual void ReplaceText(string searchValue, string newValue, bool trackChanges = false, RegexOptions options = RegexOptions.None, Formatting newFormatting = null, Formatting matchFormatting = null, MatchFormattingOptions formattingOptions = MatchFormattingOptions.SubsetMatch, bool escapeRegEx = true, bool useRegExSubstitutions = false)
{
if (string.IsNullOrEmpty(searchValue))
{
throw new ArgumentException("oldValue cannot be null or empty", "searchValue");
}
if (newValue == null)
{
throw new ArgumentException("newValue cannot be null or empty", "newValue");
}
// ReplaceText in Headers of the document.
var headerList = new List <Header> {
Document.Headers.first, Document.Headers.even, Document.Headers.odd
};
foreach (var header in headerList)
{
if (header != null)
{
foreach (var paragraph in header.Paragraphs)
{
paragraph.ReplaceText(searchValue, newValue, trackChanges, options, newFormatting, matchFormatting, formattingOptions, escapeRegEx, useRegExSubstitutions);
}
}
}
// ReplaceText int main body of document.
foreach (var paragraph in Paragraphs)
{
paragraph.ReplaceText(searchValue, newValue, trackChanges, options, newFormatting, matchFormatting, formattingOptions, escapeRegEx, useRegExSubstitutions);
}
// ReplaceText in Footers of the document.
var footerList = new List <Footer> {
Document.Footers.first, Document.Footers.even, Document.Footers.odd
};
foreach (var footer in footerList)
{
if (footer != null)
{
foreach (var paragraph in footer.Paragraphs)
{
paragraph.ReplaceText(searchValue, newValue, trackChanges, options, newFormatting, matchFormatting, formattingOptions, escapeRegEx, useRegExSubstitutions);
}
}
}
}
internal static bool ContainsEveryChildOf(XElement desired, XElement toCheck, MatchFormattingOptions fo)
{
foreach (XElement item in desired.Elements())
{
if (!(from bElement in toCheck.Elements(item.Name)
where bElement.GetAttribute(XName.Get("val", DocX.w.NamespaceName)) == item.GetAttribute(XName.Get("val", DocX.w.NamespaceName))
select bElement).Any())
{
return(false);
}
}
if (fo == MatchFormattingOptions.ExactMatch)
{
return(desired.Elements().Count() == toCheck.Elements().Count());
}
return(true);
}
public virtual void ReplaceText(string searchValue, Func <string, string> regexMatchHandler, bool trackChanges = false, RegexOptions options = RegexOptions.None, Formatting newFormatting = null, Formatting matchFormatting = null, MatchFormattingOptions formattingOptions = MatchFormattingOptions.SubsetMatch)
{
if (string.IsNullOrEmpty(searchValue))
{
throw new ArgumentException("oldValue cannot be null or empty", "searchValue");
}
if (regexMatchHandler == null)
{
throw new ArgumentException("regexMatchHandler cannot be null", "regexMatchHandler");
}
List <IParagraphContainer> list = new List <IParagraphContainer>
{
base.Document.Headers.first,
base.Document.Headers.even,
base.Document.Headers.odd,
base.Document.Footers.first,
base.Document.Footers.even,
base.Document.Footers.odd
};
foreach (IParagraphContainer item in list)
{
if (item != null)
{
foreach (Paragraph paragraph in item.Paragraphs)
{
paragraph.ReplaceText(searchValue, regexMatchHandler, trackChanges, options, newFormatting, matchFormatting, formattingOptions);
}
}
}
foreach (Paragraph paragraph2 in Paragraphs)
{
paragraph2.ReplaceText(searchValue, regexMatchHandler, trackChanges, options, newFormatting, matchFormatting, formattingOptions);
}
}
public virtual void ReplaceText(string searchValue, string newValue, bool trackChanges = false, RegexOptions options = RegexOptions.None, Formatting newFormatting = null, Formatting matchFormatting = null, MatchFormattingOptions formattingOptions = MatchFormattingOptions.SubsetMatch, bool escapeRegEx = true, bool useRegExSubstitutions = false)
{
if (string.IsNullOrEmpty(searchValue))
{
throw new ArgumentException("oldValue cannot be null or empty", "searchValue");
}
if (newValue == null)
{
throw new ArgumentException("newValue cannot be null or empty", "newValue");
}
List <Header> list = new List <Header>
{
base.Document.Headers.first,
base.Document.Headers.even,
base.Document.Headers.odd
};
foreach (Header item in list)
{
if (item != null)
{
foreach (Paragraph paragraph in item.Paragraphs)
{
paragraph.ReplaceText(searchValue, newValue, trackChanges, options, newFormatting, matchFormatting, formattingOptions, escapeRegEx, useRegExSubstitutions);
}
}
}
foreach (Paragraph paragraph2 in Paragraphs)
{
paragraph2.ReplaceText(searchValue, newValue, trackChanges, options, newFormatting, matchFormatting, formattingOptions, escapeRegEx, useRegExSubstitutions);
}
List <Footer> list2 = new List <Footer>
{
base.Document.Footers.first,
base.Document.Footers.even,
base.Document.Footers.odd
};
foreach (Footer item2 in list2)
{
if (item2 != null)
{
foreach (Paragraph paragraph3 in item2.Paragraphs)
{
paragraph3.ReplaceText(searchValue, newValue, trackChanges, options, newFormatting, matchFormatting, formattingOptions, escapeRegEx, useRegExSubstitutions);
}
}
}
}
/// <summary>
/// Replaces all occurrences of a specified System.String in this instance, with another specified System.String.
/// </summary>
/// <example>
/// <code>
/// // Load a document using a relative filename.
/// using (DocX document = DocX.Load(@"C:\Example\Test.docx"))
/// {
/// // The formatting to match.
/// Formatting matchFormatting = new Formatting();
/// matchFormatting.Size = 10;
/// matchFormatting.Italic = true;
/// matchFormatting.FontFamily = new FontFamily("Times New Roman");
///
/// // The formatting to apply to the inserted text.
/// Formatting newFormatting = new Formatting();
/// newFormatting.Size = 22;
/// newFormatting.UnderlineStyle = UnderlineStyle.dotted;
/// newFormatting.Bold = true;
///
/// // Iterate through the paragraphs in this document.
/// foreach (Paragraph p in document.Paragraphs)
/// {
/// /*
/// * Replace all instances of the string "wrong" with the string "right" and ignore case.
/// * Each inserted instance of "wrong" should use the Formatting newFormatting.
/// * Only replace an instance of "wrong" if it is Size 10, Italic and Times New Roman.
/// * SubsetMatch means that the formatting must contain all elements of the match formatting,
/// * but it can also contain additional formatting for example Color, UnderlineStyle, etc.
/// * ExactMatch means it must not contain additional formatting.
/// */
/// p.ReplaceText("wrong", "right", false, RegexOptions.IgnoreCase, newFormatting, matchFormatting, MatchFormattingOptions.SubsetMatch);
/// }
///
/// // Save all changes made to this document.
/// document.Save();
/// }// Release this document from memory.
/// </code>
/// </example>
/// <seealso cref="Paragraph.RemoveText(int, int, bool)"/>
/// <seealso cref="Paragraph.RemoveText(int, bool)"/>
/// <seealso cref="Paragraph.InsertText(int, string, bool, Formatting)"/>
/// <seealso cref="Paragraph.InsertText(string, bool, Formatting)"/>
/// <param name="newValue">A System.String to replace all occurrences of oldValue.</param>
/// <param name="oldValue">A System.String to be replaced.</param>
/// <param name="options">A bitwise OR combination of RegexOption enumeration options.</param>
/// <param name="trackChanges">Track changes</param>
/// <param name="newFormatting">The formatting to apply to the text being inserted.</param>
/// <param name="matchFormatting">The formatting that the text must match in order to be replaced.</param>
/// <param name="fo">How should formatting be matched?</param>
/// <param name="escapeRegEx">True if the oldValue needs to be escaped, otherwise false. If it represents a valid RegEx pattern this should be false.</param>
/// <param name="useRegExSubstitutions">True if RegEx-like replace should be performed, i.e. if newValue contains RegEx substitutions. Does not perform named-group substitutions (only numbered groups).</param>
public void ReplaceText(string oldValue, string newValue, bool trackChanges = false, RegexOptions options = RegexOptions.None, Formatting newFormatting = null, Formatting matchFormatting = null, MatchFormattingOptions fo = MatchFormattingOptions.SubsetMatch, bool escapeRegEx = true, bool useRegExSubstitutions = false)
{
string tText = Text;
MatchCollection mc = Regex.Matches(tText, escapeRegEx ? Regex.Escape(oldValue) : oldValue, options);
// Loop through the matches in reverse order
foreach (Match m in mc.Cast<Match>().Reverse())
{
// Assume the formatting matches until proven otherwise.
bool formattingMatch = true;
// Does the user want to match formatting?
if (matchFormatting != null)
{
// The number of characters processed so far
int processed = 0;
do
{
// Get the next run effected
Run run = GetFirstRunEffectedByEdit(m.Index + processed);
// Get this runs properties
XElement rPr = run.Xml.Element(XName.Get("rPr", DocX.w.NamespaceName));
if (rPr == null)
rPr = new Formatting().Xml;
/*
* Make sure that every formatting element in f.xml is also in this run,
* if this is not true, then their formatting does not match.
*/
if (!HelperFunctions.ContainsEveryChildOf(matchFormatting.Xml, rPr, fo))
{
formattingMatch = false;
break;
}
// We have processed some characters, so update the counter.
processed += run.Value.Length;
} while (processed < m.Length);
}
// If the formatting matches, do the replace.
if (formattingMatch)
{
string repl = newValue;
//perform RegEx substitutions. Only named groups are not supported. Everything else is supported. However character escapes are not covered.
if (useRegExSubstitutions && !String.IsNullOrEmpty(repl))
{
repl = repl.Replace("$&", m.Value);
if (m.Groups.Count > 0)
{
int lastcap = 0;
for (int k = 0; k < m.Groups.Count; k++)
{
var g = m.Groups[k];
if ((g == null) || (g.Value == ""))
continue;
repl = repl.Replace("$" + k.ToString(), g.Value);
lastcap = k;
//cannot get named groups ATM
}
repl = repl.Replace("$+", m.Groups[lastcap].Value);
}
if (m.Index > 0)
{
repl = repl.Replace("$`", tText.Substring(0, m.Index));
}
if ((m.Index + m.Length) < tText.Length)
{
repl = repl.Replace("$'", tText.Substring(m.Index + m.Length));
}
repl = repl.Replace("$_", tText);
repl = repl.Replace("$$", "$");
}
if (!String.IsNullOrEmpty(repl))
InsertText(m.Index + m.Length, repl, trackChanges, newFormatting);
if (m.Length > 0)
RemoveText(m.Index, m.Length, trackChanges);
}
}
}
public virtual void ReplaceText(string oldValue, string newValue, bool trackChanges = false, RegexOptions options = RegexOptions.None, Formatting newFormatting = null, Formatting matchFormatting = null, MatchFormattingOptions fo = MatchFormattingOptions.SubsetMatch)
{
// ReplaceText in Headers of the document.
Headers headers = Document.Headers;
List <Header> headerList = new List <Header> {
headers.first, headers.even, headers.odd
};
foreach (Header h in headerList)
{
if (h != null)
{
foreach (Paragraph p in h.Paragraphs)
{
p.ReplaceText(oldValue, newValue, trackChanges, options, newFormatting, matchFormatting, fo);
}
}
}
// ReplaceText int main body of document.
foreach (Paragraph p in Paragraphs)
{
p.ReplaceText(oldValue, newValue, trackChanges, options, newFormatting, matchFormatting, fo);
}
// ReplaceText in Footers of the document.
Footers footers = Document.Footers;
List <Footer> footerList = new List <Footer> {
footers.first, footers.even, footers.odd
};
foreach (Footer f in footerList)
{
if (f != null)
{
foreach (Paragraph p in f.Paragraphs)
{
p.ReplaceText(oldValue, newValue, trackChanges, options, newFormatting, matchFormatting, fo);
}
}
}
}
internal int RemoveTextWithFormatRecursive(XElement element, Formatting matchFormatting, MatchFormattingOptions fo)
{
var deletedCount = 0;
foreach (var x in element.Elements())
{
if ("rPr".Equals(x.Name.LocalName))
{
if (HelperFunctions.ContainsEveryChildOf(matchFormatting.Xml, x, fo))
{
x.Parent.Remove();
++deletedCount;
}
}
deletedCount += RemoveTextWithFormatRecursive(x, matchFormatting, fo);
}
return deletedCount;
}
internal int RecursiveRemoveText(XElement element, Formatting formattingToMatch, MatchFormattingOptions formattingOptions)
{
var count = 0;
foreach (var subElement in element.Elements())
{
if ("rPr".Equals(subElement.Name.LocalName))
{
if (HelperFunctions.ContainsEveryChildOf(formattingToMatch.Xml, subElement, formattingOptions))
{
subElement.Parent.Remove();
++count;
}
}
count += RecursiveRemoveText(subElement, formattingToMatch, formattingOptions);
}
return(count);
}
public virtual void ReplaceText(string oldValue, string newValue, bool trackChanges = false, RegexOptions options = RegexOptions.None, Formatting newFormatting = null, Formatting matchFormatting = null, MatchFormattingOptions fo = MatchFormattingOptions.SubsetMatch)
{
// PATCH BY HeDo - Arguments check!
if (oldValue == null || oldValue.Length == 0)
{
throw new ArgumentException("oldValue cannot be null or empty", "oldValue");
}
if (newValue == null || newValue.Length == 0)
{
throw new ArgumentException("newValue cannot be null or empty", "newValue");
}
// ReplaceText in Headers of the document.
Headers headers = Document.Headers;
List <Header> headerList = new List <Header> {
headers.first, headers.even, headers.odd
};
foreach (Header h in headerList)
{
if (h != null)
{
foreach (Paragraph p in h.Paragraphs)
{
p.ReplaceText(oldValue, newValue, trackChanges, options, newFormatting, matchFormatting, fo);
}
}
}
// ReplaceText int main body of document.
foreach (Paragraph p in Paragraphs)
{
p.ReplaceText(oldValue, newValue, trackChanges, options, newFormatting, matchFormatting, fo);
}
// ReplaceText in Footers of the document.
Footers footers = Document.Footers;
List <Footer> footerList = new List <Footer> {
footers.first, footers.even, footers.odd
};
foreach (Footer f in footerList)
{
if (f != null)
{
foreach (Paragraph p in f.Paragraphs)
{
p.ReplaceText(oldValue, newValue, trackChanges, options, newFormatting, matchFormatting, fo);
}
}
}
}
public virtual void ReplaceTextWithObject(string searchValue,
DocumentElement objectToAdd,
bool trackChanges = false,
RegexOptions options = RegexOptions.None,
Formatting matchFormatting = null,
MatchFormattingOptions fo = MatchFormattingOptions.SubsetMatch,
bool escapeRegEx = true,
bool removeEmptyParagraph = true)
{
if (string.IsNullOrEmpty(searchValue))
{
throw new ArgumentException("searchValue cannot be null or empty.", "searchValue");
}
if (objectToAdd == null)
{
throw new ArgumentException("objectToAdd cannot be null.", "objectToAdd");
}
// ReplaceText in Headers of the document.
foreach (var section in this.Document.Sections)
{
var headerList = new List <Header>()
{
section.Headers.First, section.Headers.Even, section.Headers.Odd
};
foreach (var h in headerList)
{
if (h != null)
{
foreach (var p in h.Paragraphs)
{
p.ReplaceTextWithObject(searchValue, objectToAdd, trackChanges, options, matchFormatting, fo, escapeRegEx, removeEmptyParagraph);
}
}
}
}
// ReplaceText int main body of document.
foreach (Paragraph p in this.Paragraphs)
{
p.ReplaceTextWithObject(searchValue, objectToAdd, trackChanges, options, matchFormatting, fo, escapeRegEx, removeEmptyParagraph);
}
// ReplaceText in Footers of the document.
foreach (var section in this.Document.Sections)
{
var footerList = new List <Footer> {
section.Footers.First, section.Footers.Even, section.Footers.Odd
};
foreach (var f in footerList)
{
if (f != null)
{
foreach (var p in f.Paragraphs)
{
p.ReplaceTextWithObject(searchValue, objectToAdd, trackChanges, options, matchFormatting, fo, escapeRegEx, removeEmptyParagraph);
}
}
}
}
}
public virtual void ReplaceText(string oldValue, string newValue, bool trackChanges = false, RegexOptions options = RegexOptions.None, Formatting newFormatting = null, Formatting matchFormatting = null, MatchFormattingOptions fo = MatchFormattingOptions.SubsetMatch)
{
// PATCH BY HeDo - Arguments check!
if (oldValue == null || oldValue.Length == 0)
throw new ArgumentException("oldValue cannot be null or empty", "oldValue");
if (newValue == null || newValue.Length == 0)
throw new ArgumentException("newValue cannot be null or empty", "newValue");
// ReplaceText in Headers of the document.
Headers headers = Document.Headers;
List<Header> headerList = new List<Header> { headers.first, headers.even, headers.odd };
foreach (Header h in headerList)
if (h != null)
foreach (Paragraph p in h.Paragraphs)
p.ReplaceText(oldValue, newValue, trackChanges, options, newFormatting, matchFormatting, fo);
// ReplaceText int main body of document.
foreach (Paragraph p in Paragraphs)
p.ReplaceText(oldValue, newValue, trackChanges, options, newFormatting, matchFormatting, fo);
// ReplaceText in Footers of the document.
Footers footers = Document.Footers;
List<Footer> footerList = new List<Footer> { footers.first, footers.even, footers.odd };
foreach (Footer f in footerList)
if (f != null)
foreach (Paragraph p in f.Paragraphs)
p.ReplaceText(oldValue, newValue, trackChanges, options, newFormatting, matchFormatting, fo);
}
/// <summary>
///
/// </summary>
/// <param name="searchValue">Value to find</param>
/// <param name="regexMatchHandler">A Func that accepts the matching regex search group value and passes it to this to return the replacement string</param>
/// <param name="trackChanges">Enable trackchanges</param>
/// <param name="options">Regex options</param>
/// <param name="newFormatting"></param>
/// <param name="matchFormatting"></param>
/// <param name="formattingOptions"></param>
public virtual void ReplaceText(string searchValue, Func <string, string> regexMatchHandler, bool trackChanges = false, RegexOptions options = RegexOptions.None, Formatting newFormatting = null, Formatting matchFormatting = null, MatchFormattingOptions formattingOptions = MatchFormattingOptions.SubsetMatch)
{
if (string.IsNullOrEmpty(searchValue))
{
throw new ArgumentException("oldValue cannot be null or empty", "searchValue");
}
if (regexMatchHandler == null)
{
throw new ArgumentException("regexMatchHandler cannot be null", "regexMatchHandler");
}
// ReplaceText in Headers/Footers of the document.
var containerList = new List <IParagraphContainer> {
Document.Headers.first, Document.Headers.even, Document.Headers.odd,
Document.Footers.first, Document.Footers.even, Document.Footers.odd
};
foreach (var container in containerList)
{
if (container != null)
{
foreach (var paragraph in container.Paragraphs)
{
paragraph.ReplaceText(searchValue, regexMatchHandler, trackChanges, options, newFormatting, matchFormatting, formattingOptions);
}
}
}
// ReplaceText int main body of document.
foreach (var paragraph in Paragraphs)
{
paragraph.ReplaceText(searchValue, regexMatchHandler, trackChanges, options, newFormatting, matchFormatting, formattingOptions);
}
}
public virtual void ReplaceText(string oldValue, string newValue, bool trackChanges = false, RegexOptions options = RegexOptions.None, Formatting newFormatting = null, Formatting matchFormatting = null, MatchFormattingOptions fo = MatchFormattingOptions.SubsetMatch)
{
// ReplaceText in Headers of the document.
Headers headers = Document.Headers;
List<Header> headerList = new List<Header> { headers.first, headers.even, headers.odd };
foreach (Header h in headerList)
if (h != null)
foreach (Paragraph p in h.Paragraphs)
p.ReplaceText(oldValue, newValue, trackChanges, options, newFormatting, matchFormatting, fo);
// ReplaceText int main body of document.
foreach (Paragraph p in Paragraphs)
p.ReplaceText(oldValue, newValue, trackChanges, options, newFormatting, matchFormatting, fo);
// ReplaceText in Footers of the document.
Footers footers = Document.Footers;
List<Footer> footerList = new List<Footer> { footers.first, footers.even, footers.odd };
foreach (Footer f in footerList)
if (f != null)
foreach (Paragraph p in f.Paragraphs)
p.ReplaceText(oldValue, newValue, trackChanges, options, newFormatting, matchFormatting, fo);
}
internal int RemoveTextWithFormatRecursive(XElement element, Formatting matchFormatting, MatchFormattingOptions fo)
{
var deletedCount = 0;
foreach (var x in element.Elements())
{
if ("rPr".Equals(x.Name.LocalName))
{
if (HelperFunctions.ContainsEveryChildOf(matchFormatting.Xml, x, fo))
{
x.Parent.Remove();
++deletedCount;
}
}
deletedCount += RemoveTextWithFormatRecursive(x, matchFormatting, fo);
}
return(deletedCount);
}
internal int RemoveTextWithFormatRecursive(XElement element, Formatting matchFormatting, MatchFormattingOptions fo)
{
int num = 0;
foreach (XElement item in element.Elements())
{
if ("rPr".Equals(item.Name.LocalName) && HelperFunctions.ContainsEveryChildOf(matchFormatting.Xml, item, fo))
{
item.Parent.Remove();
num++;
}
num += RemoveTextWithFormatRecursive(item, matchFormatting, fo);
}
return(num);
}
