**Inheritance:** java.lang.Object ``` public class CompareOptions ``` Allows to choose additional options for document comparison operation. To learn more, visit the [ Compare Documents ][Compare Documents] documentation article. **Examples:** Shows how to filter specific types of document elements when making a comparison. ``` // Create the original document and populate it with various kinds of elements. Document docOriginal = new Document(); DocumentBuilder builder = new DocumentBuilder(docOriginal); // Paragraph text referenced with an endnote: builder.writeln("Hello world! This is the first paragraph."); builder.insertFootnote(FootnoteType.ENDNOTE, "Original endnote text."); // Table: builder.startTable(); builder.insertCell(); builder.write("Original cell 1 text"); builder.insertCell(); builder.write("Original cell 2 text"); builder.endTable(); // Textbox: Shape textBox = builder.insertShape(ShapeType.TEXT_BOX, 150.0, 20.0); builder.moveTo(textBox.getFirstParagraph()); builder.write("Original textbox contents"); // DATE field: builder.moveTo(docOriginal.getFirstSection().getBody().appendParagraph("")); builder.insertField(" DATE "); // Comment: Comment newComment = new Comment(docOriginal, "John Doe", "J.D.", new Date()); newComment.setText("Original comment."); builder.getCurrentParagraph().appendChild(newComment); // Header: builder.moveToHeaderFooter(HeaderFooterType.HEADER_PRIMARY); builder.writeln("Original header contents."); // Create a clone of our document and perform a quick edit on each of the cloned document's elements. Document docEdited = (Document)docOriginal.deepClone(true); Paragraph firstParagraph = docEdited.getFirstSection().getBody().getFirstParagraph(); firstParagraph.getRuns().get(0).setText("hello world! this is the first paragraph, after editing."); firstParagraph.getParagraphFormat().setStyle(docEdited.getStyles().getByStyleIdentifier(StyleIdentifier.HEADING_1)); ((Footnote)docEdited.getChild(NodeType.FOOTNOTE, 0, true)).getFirstParagraph().getRuns().get(1).setText("Edited endnote text."); ((Table)docEdited.getChild(NodeType.TABLE, 0, true)).getFirstRow().getCells().get(1).getFirstParagraph().getRuns().get(0).setText("Edited Cell 2 contents"); ((Shape)docEdited.getChild(NodeType.SHAPE, 0, true)).getFirstParagraph().getRuns().get(0).setText("Edited textbox contents"); ((FieldDate)docEdited.getRange().getFields().get(0)).setUseLunarCalendar(true); ((Comment)docEdited.getChild(NodeType.COMMENT, 0, true)).getFirstParagraph().getRuns().get(0).setText("Edited comment."); docEdited.getFirstSection().getHeadersFooters().getByHeaderFooterType(HeaderFooterType.HEADER_PRIMARY).getFirstParagraph().getRuns().get(0).setText("Edited header contents."); // Comparing documents creates a revision for every edit in the edited document. // A CompareOptions object has a series of flags that can suppress revisions // on each respective type of element, effectively ignoring their change. CompareOptions compareOptions = new CompareOptions(); compareOptions.setCompareMoves(false); compareOptions.setIgnoreFormatting(false); compareOptions.setIgnoreCaseChanges(false); compareOptions.setIgnoreComments(false); compareOptions.setIgnoreTables(false); compareOptions.setIgnoreFields(false); compareOptions.setIgnoreFootnotes(false); compareOptions.setIgnoreTextboxes(false); compareOptions.setIgnoreHeadersAndFooters(false); compareOptions.setTarget(ComparisonTargetType.NEW); docOriginal.compare(docEdited, "John Doe", new Date(), compareOptions); docOriginal.save(getArtifactsDir() + "Revision.CompareOptions.docx"); ``` [Compare Documents]: https://docs.aspose.com/words/java/compare-documents/ ## Constructors | Constructor | Description | | --- | --- | | [CompareOptions()](#CompareOptions) | Initializes a new instance of this class. | ## Methods | Method | Description | | --- | --- | | [getAdvancedOptions()](#getAdvancedOptions) | Specifies advanced compare options that might help to produce more precise comparison output. | | [getCompareMoves()](#getCompareMoves) | Specifies whether to compare differences between the two documents. | | [getGranularity()](#getGranularity) | Specifies whether changes are tracked by character or by word. | | [getIgnoreCaseChanges()](#getIgnoreCaseChanges) | True indicates that documents comparison is case insensitive. | | [getIgnoreComments()](#getIgnoreComments) | Specifies whether to compare differences in comments. | | [getIgnoreDmlUniqueId()](#getIgnoreDmlUniqueId) | Specifies whether to ignore difference in DrawingML unique Id. | | [getIgnoreFields()](#getIgnoreFields) | Specifies whether to compare differences in fields. | | [getIgnoreFootnotes()](#getIgnoreFootnotes) | Specifies whether to compare differences in footnotes and endnotes. | | [getIgnoreFormatting()](#getIgnoreFormatting) | True indicates that formatting is ignored. | | [getIgnoreHeadersAndFooters()](#getIgnoreHeadersAndFooters) | True indicates that headers and footers content is ignored. | | [getIgnoreTables()](#getIgnoreTables) | Specifies whether to compare the differences in data contained in tables. | | [getIgnoreTextboxes()](#getIgnoreTextboxes) | Specifies whether to compare differences in the data contained within text boxes. | | [getTarget()](#getTarget) | Specifies which document shall be used as a target during comparison. | | [setCompareMoves(boolean value)](#setCompareMoves-boolean) | Specifies whether to compare differences between the two documents. | | [setGranularity(int value)](#setGranularity-int) | Specifies whether changes are tracked by character or by word. | | [setIgnoreCaseChanges(boolean value)](#setIgnoreCaseChanges-boolean) | True indicates that documents comparison is case insensitive. | | [setIgnoreComments(boolean value)](#setIgnoreComments-boolean) | Specifies whether to compare differences in comments. | | [setIgnoreDmlUniqueId(boolean value)](#setIgnoreDmlUniqueId-boolean) | Specifies whether to ignore difference in DrawingML unique Id. | | [setIgnoreFields(boolean value)](#setIgnoreFields-boolean) | Specifies whether to compare differences in fields. | | [setIgnoreFootnotes(boolean value)](#setIgnoreFootnotes-boolean) | Specifies whether to compare differences in footnotes and endnotes. | | [setIgnoreFormatting(boolean value)](#setIgnoreFormatting-boolean) | True indicates that formatting is ignored. | | [setIgnoreHeadersAndFooters(boolean value)](#setIgnoreHeadersAndFooters-boolean) | True indicates that headers and footers content is ignored. | | [setIgnoreTables(boolean value)](#setIgnoreTables-boolean) | Specifies whether to compare the differences in data contained in tables. | | [setIgnoreTextboxes(boolean value)](#setIgnoreTextboxes-boolean) | Specifies whether to compare differences in the data contained within text boxes. | | [setTarget(int value)](#setTarget-int) | Specifies which document shall be used as a target during comparison. | ### CompareOptions() {#CompareOptions} ``` public CompareOptions() ``` Initializes a new instance of this class. ### getAdvancedOptions() {#getAdvancedOptions} ``` public AdvancedCompareOptions getAdvancedOptions() ``` Specifies advanced compare options that might help to produce more precise comparison output. **Examples:** Shows how to compare documents ignoring DML unique ID. ``` Document docA = new Document(getMyDir() + "DML unique ID original.docx"); Document docB = new Document(getMyDir() + "DML unique ID compare.docx"); // By default, Aspose.Words do not ignore DML's unique ID, and the revisions count was 2. // If we are ignoring DML's unique ID, and revisions count were 0. CompareOptions compareOptions = new CompareOptions(); compareOptions.getAdvancedOptions().setIgnoreDmlUniqueId(isIgnoreDmlUniqueId); docA.compare(docB, "Aspose.Words", new Date(), compareOptions); Assert.assertEquals(isIgnoreDmlUniqueId ? 1 : 3, docA.getRevisions().getCount()); ``` **Returns:** [AdvancedCompareOptions](../../com.aspose.words/advancedcompareoptions/) - The corresponding [AdvancedCompareOptions](../../com.aspose.words/advancedcompareoptions/) value. ### getCompareMoves() {#getCompareMoves} ``` public boolean getCompareMoves() ``` Specifies whether to compare differences between the two documents. **Remarks:** By default move revisions are not produced. **Examples:** Shows how to filter specific types of document elements when making a comparison. ``` // Create the original document and populate it with various kinds of elements. Document docOriginal = new Document(); DocumentBuilder builder = new DocumentBuilder(docOriginal); // Paragraph text referenced with an endnote: builder.writeln("Hello world! This is the first paragraph."); builder.insertFootnote(FootnoteType.ENDNOTE, "Original endnote text."); // Table: builder.startTable(); builder.insertCell(); builder.write("Original cell 1 text"); builder.insertCell(); builder.write("Original cell 2 text"); builder.endTable(); // Textbox: Shape textBox = builder.insertShape(ShapeType.TEXT_BOX, 150.0, 20.0); builder.moveTo(textBox.getFirstParagraph()); builder.write("Original textbox contents"); // DATE field: builder.moveTo(docOriginal.getFirstSection().getBody().appendParagraph("")); builder.insertField(" DATE "); // Comment: Comment newComment = new Comment(docOriginal, "John Doe", "J.D.", new Date()); newComment.setText("Original comment."); builder.getCurrentParagraph().appendChild(newComment); // Header: builder.moveToHeaderFooter(HeaderFooterType.HEADER_PRIMARY); builder.writeln("Original header contents."); // Create a clone of our document and perform a quick edit on each of the cloned document's elements. Document docEdited = (Document)docOriginal.deepClone(true); Paragraph firstParagraph = docEdited.getFirstSection().getBody().getFirstParagraph(); firstParagraph.getRuns().get(0).setText("hello world! this is the first paragraph, after editing."); firstParagraph.getParagraphFormat().setStyle(docEdited.getStyles().getByStyleIdentifier(StyleIdentifier.HEADING_1)); ((Footnote)docEdited.getChild(NodeType.FOOTNOTE, 0, true)).getFirstParagraph().getRuns().get(1).setText("Edited endnote text."); ((Table)docEdited.getChild(NodeType.TABLE, 0, true)).getFirstRow().getCells().get(1).getFirstParagraph().getRuns().get(0).setText("Edited Cell 2 contents"); ((Shape)docEdited.getChild(NodeType.SHAPE, 0, true)).getFirstParagraph().getRuns().get(0).setText("Edited textbox contents"); ((FieldDate)docEdited.getRange().getFields().get(0)).setUseLunarCalendar(true); ((Comment)docEdited.getChild(NodeType.COMMENT, 0, true)).getFirstParagraph().getRuns().get(0).setText("Edited comment."); docEdited.getFirstSection().getHeadersFooters().getByHeaderFooterType(HeaderFooterType.HEADER_PRIMARY).getFirstParagraph().getRuns().get(0).setText("Edited header contents."); // Comparing documents creates a revision for every edit in the edited document. // A CompareOptions object has a series of flags that can suppress revisions // on each respective type of element, effectively ignoring their change. CompareOptions compareOptions = new CompareOptions(); compareOptions.setCompareMoves(false); compareOptions.setIgnoreFormatting(false); compareOptions.setIgnoreCaseChanges(false); compareOptions.setIgnoreComments(false); compareOptions.setIgnoreTables(false); compareOptions.setIgnoreFields(false); compareOptions.setIgnoreFootnotes(false); compareOptions.setIgnoreTextboxes(false); compareOptions.setIgnoreHeadersAndFooters(false); compareOptions.setTarget(ComparisonTargetType.NEW); docOriginal.compare(docEdited, "John Doe", new Date(), compareOptions); docOriginal.save(getArtifactsDir() + "Revision.CompareOptions.docx"); ``` **Returns:** boolean - The corresponding boolean value. ### getGranularity() {#getGranularity} ``` public int getGranularity() ``` Specifies whether changes are tracked by character or by word. **Remarks:** Default value is [Granularity.WORD\_LEVEL](../../com.aspose.words/granularity/\#WORD-LEVEL). **Examples:** Shows to specify a granularity while comparing documents. ``` Document docA = new Document(); DocumentBuilder builderA = new DocumentBuilder(docA); builderA.writeln("Alpha Lorem ipsum dolor sit amet, consectetur adipiscing elit"); Document docB = new Document(); DocumentBuilder builderB = new DocumentBuilder(docB); builderB.writeln("Lorems ipsum dolor sit amet consectetur - \"adipiscing\" elit"); // Specify whether changes are tracking // by character ('Granularity.CharLevel'), or by word ('Granularity.WordLevel'). CompareOptions compareOptions = new CompareOptions(); compareOptions.setGranularity(granularity); docA.compare(docB, "author", new Date(), compareOptions); // The first document's collection of revision groups contains all the differences between documents. RevisionGroupCollection groups = docA.getRevisions().getGroups(); Assert.assertEquals(5, groups.getCount()); ``` **Returns:** int - The corresponding int value. The returned value is one of [Granularity](../../com.aspose.words/granularity/) constants. ### getIgnoreCaseChanges() {#getIgnoreCaseChanges} ``` public boolean getIgnoreCaseChanges() ``` True indicates that documents comparison is case insensitive. **Remarks:** By default comparison is case sensitive. **Examples:** Shows how to filter specific types of document elements when making a comparison. ``` // Create the original document and populate it with various kinds of elements. Document docOriginal = new Document(); DocumentBuilder builder = new DocumentBuilder(docOriginal); // Paragraph text referenced with an endnote: builder.writeln("Hello world! This is the first paragraph."); builder.insertFootnote(FootnoteType.ENDNOTE, "Original endnote text."); // Table: builder.startTable(); builder.insertCell(); builder.write("Original cell 1 text"); builder.insertCell(); builder.write("Original cell 2 text"); builder.endTable(); // Textbox: Shape textBox = builder.insertShape(ShapeType.TEXT_BOX, 150.0, 20.0); builder.moveTo(textBox.getFirstParagraph()); builder.write("Original textbox contents"); // DATE field: builder.moveTo(docOriginal.getFirstSection().getBody().appendParagraph("")); builder.insertField(" DATE "); // Comment: Comment newComment = new Comment(docOriginal, "John Doe", "J.D.", new Date()); newComment.setText("Original comment."); builder.getCurrentParagraph().appendChild(newComment); // Header: builder.moveToHeaderFooter(HeaderFooterType.HEADER_PRIMARY); builder.writeln("Original header contents."); // Create a clone of our document and perform a quick edit on each of the cloned document's elements. Document docEdited = (Document)docOriginal.deepClone(true); Paragraph firstParagraph = docEdited.getFirstSection().getBody().getFirstParagraph(); firstParagraph.getRuns().get(0).setText("hello world! this is the first paragraph, after editing."); firstParagraph.getParagraphFormat().setStyle(docEdited.getStyles().getByStyleIdentifier(StyleIdentifier.HEADING_1)); ((Footnote)docEdited.getChild(NodeType.FOOTNOTE, 0, true)).getFirstParagraph().getRuns().get(1).setText("Edited endnote text."); ((Table)docEdited.getChild(NodeType.TABLE, 0, true)).getFirstRow().getCells().get(1).getFirstParagraph().getRuns().get(0).setText("Edited Cell 2 contents"); ((Shape)docEdited.getChild(NodeType.SHAPE, 0, true)).getFirstParagraph().getRuns().get(0).setText("Edited textbox contents"); ((FieldDate)docEdited.getRange().getFields().get(0)).setUseLunarCalendar(true); ((Comment)docEdited.getChild(NodeType.COMMENT, 0, true)).getFirstParagraph().getRuns().get(0).setText("Edited comment."); docEdited.getFirstSection().getHeadersFooters().getByHeaderFooterType(HeaderFooterType.HEADER_PRIMARY).getFirstParagraph().getRuns().get(0).setText("Edited header contents."); // Comparing documents creates a revision for every edit in the edited document. // A CompareOptions object has a series of flags that can suppress revisions // on each respective type of element, effectively ignoring their change. CompareOptions compareOptions = new CompareOptions(); compareOptions.setCompareMoves(false); compareOptions.setIgnoreFormatting(false); compareOptions.setIgnoreCaseChanges(false); compareOptions.setIgnoreComments(false); compareOptions.setIgnoreTables(false); compareOptions.setIgnoreFields(false); compareOptions.setIgnoreFootnotes(false); compareOptions.setIgnoreTextboxes(false); compareOptions.setIgnoreHeadersAndFooters(false); compareOptions.setTarget(ComparisonTargetType.NEW); docOriginal.compare(docEdited, "John Doe", new Date(), compareOptions); docOriginal.save(getArtifactsDir() + "Revision.CompareOptions.docx"); ``` **Returns:** boolean - The corresponding boolean value. ### getIgnoreComments() {#getIgnoreComments} ``` public boolean getIgnoreComments() ``` Specifies whether to compare differences in comments. **Remarks:** By default, comments are not ignored. **Examples:** Shows how to filter specific types of document elements when making a comparison. ``` // Create the original document and populate it with various kinds of elements. Document docOriginal = new Document(); DocumentBuilder builder = new DocumentBuilder(docOriginal); // Paragraph text referenced with an endnote: builder.writeln("Hello world! This is the first paragraph."); builder.insertFootnote(FootnoteType.ENDNOTE, "Original endnote text."); // Table: builder.startTable(); builder.insertCell(); builder.write("Original cell 1 text"); builder.insertCell(); builder.write("Original cell 2 text"); builder.endTable(); // Textbox: Shape textBox = builder.insertShape(ShapeType.TEXT_BOX, 150.0, 20.0); builder.moveTo(textBox.getFirstParagraph()); builder.write("Original textbox contents"); // DATE field: builder.moveTo(docOriginal.getFirstSection().getBody().appendParagraph("")); builder.insertField(" DATE "); // Comment: Comment newComment = new Comment(docOriginal, "John Doe", "J.D.", new Date()); newComment.setText("Original comment."); builder.getCurrentParagraph().appendChild(newComment); // Header: builder.moveToHeaderFooter(HeaderFooterType.HEADER_PRIMARY); builder.writeln("Original header contents."); // Create a clone of our document and perform a quick edit on each of the cloned document's elements. Document docEdited = (Document)docOriginal.deepClone(true); Paragraph firstParagraph = docEdited.getFirstSection().getBody().getFirstParagraph(); firstParagraph.getRuns().get(0).setText("hello world! this is the first paragraph, after editing."); firstParagraph.getParagraphFormat().setStyle(docEdited.getStyles().getByStyleIdentifier(StyleIdentifier.HEADING_1)); ((Footnote)docEdited.getChild(NodeType.FOOTNOTE, 0, true)).getFirstParagraph().getRuns().get(1).setText("Edited endnote text."); ((Table)docEdited.getChild(NodeType.TABLE, 0, true)).getFirstRow().getCells().get(1).getFirstParagraph().getRuns().get(0).setText("Edited Cell 2 contents"); ((Shape)docEdited.getChild(NodeType.SHAPE, 0, true)).getFirstParagraph().getRuns().get(0).setText("Edited textbox contents"); ((FieldDate)docEdited.getRange().getFields().get(0)).setUseLunarCalendar(true); ((Comment)docEdited.getChild(NodeType.COMMENT, 0, true)).getFirstParagraph().getRuns().get(0).setText("Edited comment."); docEdited.getFirstSection().getHeadersFooters().getByHeaderFooterType(HeaderFooterType.HEADER_PRIMARY).getFirstParagraph().getRuns().get(0).setText("Edited header contents."); // Comparing documents creates a revision for every edit in the edited document. // A CompareOptions object has a series of flags that can suppress revisions // on each respective type of element, effectively ignoring their change. CompareOptions compareOptions = new CompareOptions(); compareOptions.setCompareMoves(false); compareOptions.setIgnoreFormatting(false); compareOptions.setIgnoreCaseChanges(false); compareOptions.setIgnoreComments(false); compareOptions.setIgnoreTables(false); compareOptions.setIgnoreFields(false); compareOptions.setIgnoreFootnotes(false); compareOptions.setIgnoreTextboxes(false); compareOptions.setIgnoreHeadersAndFooters(false); compareOptions.setTarget(ComparisonTargetType.NEW); docOriginal.compare(docEdited, "John Doe", new Date(), compareOptions); docOriginal.save(getArtifactsDir() + "Revision.CompareOptions.docx"); ``` **Returns:** boolean - The corresponding boolean value. ### getIgnoreDmlUniqueId() {#getIgnoreDmlUniqueId} ``` public boolean getIgnoreDmlUniqueId() ``` Specifies whether to ignore difference in DrawingML unique Id. **Remarks:** Default value is false . **Examples:** Shows how to compare documents ignoring DML unique ID. ``` Document docA = new Document(getMyDir() + "DML unique ID original.docx"); Document docB = new Document(getMyDir() + "DML unique ID compare.docx"); // By default, Aspose.Words do not ignore DML's unique ID, and the revisions count was 2. // If we are ignoring DML's unique ID, and revisions count were 0. CompareOptions compareOptions = new CompareOptions(); compareOptions.getAdvancedOptions().setIgnoreDmlUniqueId(isIgnoreDmlUniqueId); docA.compare(docB, "Aspose.Words", new Date(), compareOptions); Assert.assertEquals(isIgnoreDmlUniqueId ? 1 : 3, docA.getRevisions().getCount()); ``` **Returns:** boolean - The corresponding boolean value. ### getIgnoreFields() {#getIgnoreFields} ``` public boolean getIgnoreFields() ``` Specifies whether to compare differences in fields. **Remarks:** By default fields are not ignored. **Examples:** Shows how to filter specific types of document elements when making a comparison. ``` // Create the original document and populate it with various kinds of elements. Document docOriginal = new Document(); DocumentBuilder builder = new DocumentBuilder(docOriginal); // Paragraph text referenced with an endnote: builder.writeln("Hello world! This is the first paragraph."); builder.insertFootnote(FootnoteType.ENDNOTE, "Original endnote text."); // Table: builder.startTable(); builder.insertCell(); builder.write("Original cell 1 text"); builder.insertCell(); builder.write("Original cell 2 text"); builder.endTable(); // Textbox: Shape textBox = builder.insertShape(ShapeType.TEXT_BOX, 150.0, 20.0); builder.moveTo(textBox.getFirstParagraph()); builder.write("Original textbox contents"); // DATE field: builder.moveTo(docOriginal.getFirstSection().getBody().appendParagraph("")); builder.insertField(" DATE "); // Comment: Comment newComment = new Comment(docOriginal, "John Doe", "J.D.", new Date()); newComment.setText("Original comment."); builder.getCurrentParagraph().appendChild(newComment); // Header: builder.moveToHeaderFooter(HeaderFooterType.HEADER_PRIMARY); builder.writeln("Original header contents."); // Create a clone of our document and perform a quick edit on each of the cloned document's elements. Document docEdited = (Document)docOriginal.deepClone(true); Paragraph firstParagraph = docEdited.getFirstSection().getBody().getFirstParagraph(); firstParagraph.getRuns().get(0).setText("hello world! this is the first paragraph, after editing."); firstParagraph.getParagraphFormat().setStyle(docEdited.getStyles().getByStyleIdentifier(StyleIdentifier.HEADING_1)); ((Footnote)docEdited.getChild(NodeType.FOOTNOTE, 0, true)).getFirstParagraph().getRuns().get(1).setText("Edited endnote text."); ((Table)docEdited.getChild(NodeType.TABLE, 0, true)).getFirstRow().getCells().get(1).getFirstParagraph().getRuns().get(0).setText("Edited Cell 2 contents"); ((Shape)docEdited.getChild(NodeType.SHAPE, 0, true)).getFirstParagraph().getRuns().get(0).setText("Edited textbox contents"); ((FieldDate)docEdited.getRange().getFields().get(0)).setUseLunarCalendar(true); ((Comment)docEdited.getChild(NodeType.COMMENT, 0, true)).getFirstParagraph().getRuns().get(0).setText("Edited comment."); docEdited.getFirstSection().getHeadersFooters().getByHeaderFooterType(HeaderFooterType.HEADER_PRIMARY).getFirstParagraph().getRuns().get(0).setText("Edited header contents."); // Comparing documents creates a revision for every edit in the edited document. // A CompareOptions object has a series of flags that can suppress revisions // on each respective type of element, effectively ignoring their change. CompareOptions compareOptions = new CompareOptions(); compareOptions.setCompareMoves(false); compareOptions.setIgnoreFormatting(false); compareOptions.setIgnoreCaseChanges(false); compareOptions.setIgnoreComments(false); compareOptions.setIgnoreTables(false); compareOptions.setIgnoreFields(false); compareOptions.setIgnoreFootnotes(false); compareOptions.setIgnoreTextboxes(false); compareOptions.setIgnoreHeadersAndFooters(false); compareOptions.setTarget(ComparisonTargetType.NEW); docOriginal.compare(docEdited, "John Doe", new Date(), compareOptions); docOriginal.save(getArtifactsDir() + "Revision.CompareOptions.docx"); ``` **Returns:** boolean - The corresponding boolean value. ### getIgnoreFootnotes() {#getIgnoreFootnotes} ``` public boolean getIgnoreFootnotes() ``` Specifies whether to compare differences in footnotes and endnotes. **Remarks:** By default, footnotes are not ignored. **Examples:** Shows how to filter specific types of document elements when making a comparison. ``` // Create the original document and populate it with various kinds of elements. Document docOriginal = new Document(); DocumentBuilder builder = new DocumentBuilder(docOriginal); // Paragraph text referenced with an endnote: builder.writeln("Hello world! This is the first paragraph."); builder.insertFootnote(FootnoteType.ENDNOTE, "Original endnote text."); // Table: builder.startTable(); builder.insertCell(); builder.write("Original cell 1 text"); builder.insertCell(); builder.write("Original cell 2 text"); builder.endTable(); // Textbox: Shape textBox = builder.insertShape(ShapeType.TEXT_BOX, 150.0, 20.0); builder.moveTo(textBox.getFirstParagraph()); builder.write("Original textbox contents"); // DATE field: builder.moveTo(docOriginal.getFirstSection().getBody().appendParagraph("")); builder.insertField(" DATE "); // Comment: Comment newComment = new Comment(docOriginal, "John Doe", "J.D.", new Date()); newComment.setText("Original comment."); builder.getCurrentParagraph().appendChild(newComment); // Header: builder.moveToHeaderFooter(HeaderFooterType.HEADER_PRIMARY); builder.writeln("Original header contents."); // Create a clone of our document and perform a quick edit on each of the cloned document's elements. Document docEdited = (Document)docOriginal.deepClone(true); Paragraph firstParagraph = docEdited.getFirstSection().getBody().getFirstParagraph(); firstParagraph.getRuns().get(0).setText("hello world! this is the first paragraph, after editing."); firstParagraph.getParagraphFormat().setStyle(docEdited.getStyles().getByStyleIdentifier(StyleIdentifier.HEADING_1)); ((Footnote)docEdited.getChild(NodeType.FOOTNOTE, 0, true)).getFirstParagraph().getRuns().get(1).setText("Edited endnote text."); ((Table)docEdited.getChild(NodeType.TABLE, 0, true)).getFirstRow().getCells().get(1).getFirstParagraph().getRuns().get(0).setText("Edited Cell 2 contents"); ((Shape)docEdited.getChild(NodeType.SHAPE, 0, true)).getFirstParagraph().getRuns().get(0).setText("Edited textbox contents"); ((FieldDate)docEdited.getRange().getFields().get(0)).setUseLunarCalendar(true); ((Comment)docEdited.getChild(NodeType.COMMENT, 0, true)).getFirstParagraph().getRuns().get(0).setText("Edited comment."); docEdited.getFirstSection().getHeadersFooters().getByHeaderFooterType(HeaderFooterType.HEADER_PRIMARY).getFirstParagraph().getRuns().get(0).setText("Edited header contents."); // Comparing documents creates a revision for every edit in the edited document. // A CompareOptions object has a series of flags that can suppress revisions // on each respective type of element, effectively ignoring their change. CompareOptions compareOptions = new CompareOptions(); compareOptions.setCompareMoves(false); compareOptions.setIgnoreFormatting(false); compareOptions.setIgnoreCaseChanges(false); compareOptions.setIgnoreComments(false); compareOptions.setIgnoreTables(false); compareOptions.setIgnoreFields(false); compareOptions.setIgnoreFootnotes(false); compareOptions.setIgnoreTextboxes(false); compareOptions.setIgnoreHeadersAndFooters(false); compareOptions.setTarget(ComparisonTargetType.NEW); docOriginal.compare(docEdited, "John Doe", new Date(), compareOptions); docOriginal.save(getArtifactsDir() + "Revision.CompareOptions.docx"); ``` **Returns:** boolean - The corresponding boolean value. ### getIgnoreFormatting() {#getIgnoreFormatting} ``` public boolean getIgnoreFormatting() ``` True indicates that formatting is ignored. **Remarks:** By default, document formatting is not ignored. **Examples:** Shows how to filter specific types of document elements when making a comparison. ``` // Create the original document and populate it with various kinds of elements. Document docOriginal = new Document(); DocumentBuilder builder = new DocumentBuilder(docOriginal); // Paragraph text referenced with an endnote: builder.writeln("Hello world! This is the first paragraph."); builder.insertFootnote(FootnoteType.ENDNOTE, "Original endnote text."); // Table: builder.startTable(); builder.insertCell(); builder.write("Original cell 1 text"); builder.insertCell(); builder.write("Original cell 2 text"); builder.endTable(); // Textbox: Shape textBox = builder.insertShape(ShapeType.TEXT_BOX, 150.0, 20.0); builder.moveTo(textBox.getFirstParagraph()); builder.write("Original textbox contents"); // DATE field: builder.moveTo(docOriginal.getFirstSection().getBody().appendParagraph("")); builder.insertField(" DATE "); // Comment: Comment newComment = new Comment(docOriginal, "John Doe", "J.D.", new Date()); newComment.setText("Original comment."); builder.getCurrentParagraph().appendChild(newComment); // Header: builder.moveToHeaderFooter(HeaderFooterType.HEADER_PRIMARY); builder.writeln("Original header contents."); // Create a clone of our document and perform a quick edit on each of the cloned document's elements. Document docEdited = (Document)docOriginal.deepClone(true); Paragraph firstParagraph = docEdited.getFirstSection().getBody().getFirstParagraph(); firstParagraph.getRuns().get(0).setText("hello world! this is the first paragraph, after editing."); firstParagraph.getParagraphFormat().setStyle(docEdited.getStyles().getByStyleIdentifier(StyleIdentifier.HEADING_1)); ((Footnote)docEdited.getChild(NodeType.FOOTNOTE, 0, true)).getFirstParagraph().getRuns().get(1).setText("Edited endnote text."); ((Table)docEdited.getChild(NodeType.TABLE, 0, true)).getFirstRow().getCells().get(1).getFirstParagraph().getRuns().get(0).setText("Edited Cell 2 contents"); ((Shape)docEdited.getChild(NodeType.SHAPE, 0, true)).getFirstParagraph().getRuns().get(0).setText("Edited textbox contents"); ((FieldDate)docEdited.getRange().getFields().get(0)).setUseLunarCalendar(true); ((Comment)docEdited.getChild(NodeType.COMMENT, 0, true)).getFirstParagraph().getRuns().get(0).setText("Edited comment."); docEdited.getFirstSection().getHeadersFooters().getByHeaderFooterType(HeaderFooterType.HEADER_PRIMARY).getFirstParagraph().getRuns().get(0).setText("Edited header contents."); // Comparing documents creates a revision for every edit in the edited document. // A CompareOptions object has a series of flags that can suppress revisions // on each respective type of element, effectively ignoring their change. CompareOptions compareOptions = new CompareOptions(); compareOptions.setCompareMoves(false); compareOptions.setIgnoreFormatting(false); compareOptions.setIgnoreCaseChanges(false); compareOptions.setIgnoreComments(false); compareOptions.setIgnoreTables(false); compareOptions.setIgnoreFields(false); compareOptions.setIgnoreFootnotes(false); compareOptions.setIgnoreTextboxes(false); compareOptions.setIgnoreHeadersAndFooters(false); compareOptions.setTarget(ComparisonTargetType.NEW); docOriginal.compare(docEdited, "John Doe", new Date(), compareOptions); docOriginal.save(getArtifactsDir() + "Revision.CompareOptions.docx"); ``` **Returns:** boolean - The corresponding boolean value. ### getIgnoreHeadersAndFooters() {#getIgnoreHeadersAndFooters} ``` public boolean getIgnoreHeadersAndFooters() ``` True indicates that headers and footers content is ignored. **Remarks:** By default, headers and footers are not ignored. **Examples:** Shows how to filter specific types of document elements when making a comparison. ``` // Create the original document and populate it with various kinds of elements. Document docOriginal = new Document(); DocumentBuilder builder = new DocumentBuilder(docOriginal); // Paragraph text referenced with an endnote: builder.writeln("Hello world! This is the first paragraph."); builder.insertFootnote(FootnoteType.ENDNOTE, "Original endnote text."); // Table: builder.startTable(); builder.insertCell(); builder.write("Original cell 1 text"); builder.insertCell(); builder.write("Original cell 2 text"); builder.endTable(); // Textbox: Shape textBox = builder.insertShape(ShapeType.TEXT_BOX, 150.0, 20.0); builder.moveTo(textBox.getFirstParagraph()); builder.write("Original textbox contents"); // DATE field: builder.moveTo(docOriginal.getFirstSection().getBody().appendParagraph("")); builder.insertField(" DATE "); // Comment: Comment newComment = new Comment(docOriginal, "John Doe", "J.D.", new Date()); newComment.setText("Original comment."); builder.getCurrentParagraph().appendChild(newComment); // Header: builder.moveToHeaderFooter(HeaderFooterType.HEADER_PRIMARY); builder.writeln("Original header contents."); // Create a clone of our document and perform a quick edit on each of the cloned document's elements. Document docEdited = (Document)docOriginal.deepClone(true); Paragraph firstParagraph = docEdited.getFirstSection().getBody().getFirstParagraph(); firstParagraph.getRuns().get(0).setText("hello world! this is the first paragraph, after editing."); firstParagraph.getParagraphFormat().setStyle(docEdited.getStyles().getByStyleIdentifier(StyleIdentifier.HEADING_1)); ((Footnote)docEdited.getChild(NodeType.FOOTNOTE, 0, true)).getFirstParagraph().getRuns().get(1).setText("Edited endnote text."); ((Table)docEdited.getChild(NodeType.TABLE, 0, true)).getFirstRow().getCells().get(1).getFirstParagraph().getRuns().get(0).setText("Edited Cell 2 contents"); ((Shape)docEdited.getChild(NodeType.SHAPE, 0, true)).getFirstParagraph().getRuns().get(0).setText("Edited textbox contents"); ((FieldDate)docEdited.getRange().getFields().get(0)).setUseLunarCalendar(true); ((Comment)docEdited.getChild(NodeType.COMMENT, 0, true)).getFirstParagraph().getRuns().get(0).setText("Edited comment."); docEdited.getFirstSection().getHeadersFooters().getByHeaderFooterType(HeaderFooterType.HEADER_PRIMARY).getFirstParagraph().getRuns().get(0).setText("Edited header contents."); // Comparing documents creates a revision for every edit in the edited document. // A CompareOptions object has a series of flags that can suppress revisions // on each respective type of element, effectively ignoring their change. CompareOptions compareOptions = new CompareOptions(); compareOptions.setCompareMoves(false); compareOptions.setIgnoreFormatting(false); compareOptions.setIgnoreCaseChanges(false); compareOptions.setIgnoreComments(false); compareOptions.setIgnoreTables(false); compareOptions.setIgnoreFields(false); compareOptions.setIgnoreFootnotes(false); compareOptions.setIgnoreTextboxes(false); compareOptions.setIgnoreHeadersAndFooters(false); compareOptions.setTarget(ComparisonTargetType.NEW); docOriginal.compare(docEdited, "John Doe", new Date(), compareOptions); docOriginal.save(getArtifactsDir() + "Revision.CompareOptions.docx"); ``` **Returns:** boolean - The corresponding boolean value. ### getIgnoreTables() {#getIgnoreTables} ``` public boolean getIgnoreTables() ``` Specifies whether to compare the differences in data contained in tables. **Remarks:** By default tables are not ignored. **Examples:** Shows how to filter specific types of document elements when making a comparison. ``` // Create the original document and populate it with various kinds of elements. Document docOriginal = new Document(); DocumentBuilder builder = new DocumentBuilder(docOriginal); // Paragraph text referenced with an endnote: builder.writeln("Hello world! This is the first paragraph."); builder.insertFootnote(FootnoteType.ENDNOTE, "Original endnote text."); // Table: builder.startTable(); builder.insertCell(); builder.write("Original cell 1 text"); builder.insertCell(); builder.write("Original cell 2 text"); builder.endTable(); // Textbox: Shape textBox = builder.insertShape(ShapeType.TEXT_BOX, 150.0, 20.0); builder.moveTo(textBox.getFirstParagraph()); builder.write("Original textbox contents"); // DATE field: builder.moveTo(docOriginal.getFirstSection().getBody().appendParagraph("")); builder.insertField(" DATE "); // Comment: Comment newComment = new Comment(docOriginal, "John Doe", "J.D.", new Date()); newComment.setText("Original comment."); builder.getCurrentParagraph().appendChild(newComment); // Header: builder.moveToHeaderFooter(HeaderFooterType.HEADER_PRIMARY); builder.writeln("Original header contents."); // Create a clone of our document and perform a quick edit on each of the cloned document's elements. Document docEdited = (Document)docOriginal.deepClone(true); Paragraph firstParagraph = docEdited.getFirstSection().getBody().getFirstParagraph(); firstParagraph.getRuns().get(0).setText("hello world! this is the first paragraph, after editing."); firstParagraph.getParagraphFormat().setStyle(docEdited.getStyles().getByStyleIdentifier(StyleIdentifier.HEADING_1)); ((Footnote)docEdited.getChild(NodeType.FOOTNOTE, 0, true)).getFirstParagraph().getRuns().get(1).setText("Edited endnote text."); ((Table)docEdited.getChild(NodeType.TABLE, 0, true)).getFirstRow().getCells().get(1).getFirstParagraph().getRuns().get(0).setText("Edited Cell 2 contents"); ((Shape)docEdited.getChild(NodeType.SHAPE, 0, true)).getFirstParagraph().getRuns().get(0).setText("Edited textbox contents"); ((FieldDate)docEdited.getRange().getFields().get(0)).setUseLunarCalendar(true); ((Comment)docEdited.getChild(NodeType.COMMENT, 0, true)).getFirstParagraph().getRuns().get(0).setText("Edited comment."); docEdited.getFirstSection().getHeadersFooters().getByHeaderFooterType(HeaderFooterType.HEADER_PRIMARY).getFirstParagraph().getRuns().get(0).setText("Edited header contents."); // Comparing documents creates a revision for every edit in the edited document. // A CompareOptions object has a series of flags that can suppress revisions // on each respective type of element, effectively ignoring their change. CompareOptions compareOptions = new CompareOptions(); compareOptions.setCompareMoves(false); compareOptions.setIgnoreFormatting(false); compareOptions.setIgnoreCaseChanges(false); compareOptions.setIgnoreComments(false); compareOptions.setIgnoreTables(false); compareOptions.setIgnoreFields(false); compareOptions.setIgnoreFootnotes(false); compareOptions.setIgnoreTextboxes(false); compareOptions.setIgnoreHeadersAndFooters(false); compareOptions.setTarget(ComparisonTargetType.NEW); docOriginal.compare(docEdited, "John Doe", new Date(), compareOptions); docOriginal.save(getArtifactsDir() + "Revision.CompareOptions.docx"); ``` **Returns:** boolean - The corresponding boolean value. ### getIgnoreTextboxes() {#getIgnoreTextboxes} ``` public boolean getIgnoreTextboxes() ``` Specifies whether to compare differences in the data contained within text boxes. **Remarks:** By default, textboxes are not ignored. **Examples:** Shows how to filter specific types of document elements when making a comparison. ``` // Create the original document and populate it with various kinds of elements. Document docOriginal = new Document(); DocumentBuilder builder = new DocumentBuilder(docOriginal); // Paragraph text referenced with an endnote: builder.writeln("Hello world! This is the first paragraph."); builder.insertFootnote(FootnoteType.ENDNOTE, "Original endnote text."); // Table: builder.startTable(); builder.insertCell(); builder.write("Original cell 1 text"); builder.insertCell(); builder.write("Original cell 2 text"); builder.endTable(); // Textbox: Shape textBox = builder.insertShape(ShapeType.TEXT_BOX, 150.0, 20.0); builder.moveTo(textBox.getFirstParagraph()); builder.write("Original textbox contents"); // DATE field: builder.moveTo(docOriginal.getFirstSection().getBody().appendParagraph("")); builder.insertField(" DATE "); // Comment: Comment newComment = new Comment(docOriginal, "John Doe", "J.D.", new Date()); newComment.setText("Original comment."); builder.getCurrentParagraph().appendChild(newComment); // Header: builder.moveToHeaderFooter(HeaderFooterType.HEADER_PRIMARY); builder.writeln("Original header contents."); // Create a clone of our document and perform a quick edit on each of the cloned document's elements. Document docEdited = (Document)docOriginal.deepClone(true); Paragraph firstParagraph = docEdited.getFirstSection().getBody().getFirstParagraph(); firstParagraph.getRuns().get(0).setText("hello world! this is the first paragraph, after editing."); firstParagraph.getParagraphFormat().setStyle(docEdited.getStyles().getByStyleIdentifier(StyleIdentifier.HEADING_1)); ((Footnote)docEdited.getChild(NodeType.FOOTNOTE, 0, true)).getFirstParagraph().getRuns().get(1).setText("Edited endnote text."); ((Table)docEdited.getChild(NodeType.TABLE, 0, true)).getFirstRow().getCells().get(1).getFirstParagraph().getRuns().get(0).setText("Edited Cell 2 contents"); ((Shape)docEdited.getChild(NodeType.SHAPE, 0, true)).getFirstParagraph().getRuns().get(0).setText("Edited textbox contents"); ((FieldDate)docEdited.getRange().getFields().get(0)).setUseLunarCalendar(true); ((Comment)docEdited.getChild(NodeType.COMMENT, 0, true)).getFirstParagraph().getRuns().get(0).setText("Edited comment."); docEdited.getFirstSection().getHeadersFooters().getByHeaderFooterType(HeaderFooterType.HEADER_PRIMARY).getFirstParagraph().getRuns().get(0).setText("Edited header contents."); // Comparing documents creates a revision for every edit in the edited document. // A CompareOptions object has a series of flags that can suppress revisions // on each respective type of element, effectively ignoring their change. CompareOptions compareOptions = new CompareOptions(); compareOptions.setCompareMoves(false); compareOptions.setIgnoreFormatting(false); compareOptions.setIgnoreCaseChanges(false); compareOptions.setIgnoreComments(false); compareOptions.setIgnoreTables(false); compareOptions.setIgnoreFields(false); compareOptions.setIgnoreFootnotes(false); compareOptions.setIgnoreTextboxes(false); compareOptions.setIgnoreHeadersAndFooters(false); compareOptions.setTarget(ComparisonTargetType.NEW); docOriginal.compare(docEdited, "John Doe", new Date(), compareOptions); docOriginal.save(getArtifactsDir() + "Revision.CompareOptions.docx"); ``` **Returns:** boolean - The corresponding boolean value. ### getTarget() {#getTarget} ``` public int getTarget() ``` Specifies which document shall be used as a target during comparison. **Examples:** Shows how to filter specific types of document elements when making a comparison. ``` // Create the original document and populate it with various kinds of elements. Document docOriginal = new Document(); DocumentBuilder builder = new DocumentBuilder(docOriginal); // Paragraph text referenced with an endnote: builder.writeln("Hello world! This is the first paragraph."); builder.insertFootnote(FootnoteType.ENDNOTE, "Original endnote text."); // Table: builder.startTable(); builder.insertCell(); builder.write("Original cell 1 text"); builder.insertCell(); builder.write("Original cell 2 text"); builder.endTable(); // Textbox: Shape textBox = builder.insertShape(ShapeType.TEXT_BOX, 150.0, 20.0); builder.moveTo(textBox.getFirstParagraph()); builder.write("Original textbox contents"); // DATE field: builder.moveTo(docOriginal.getFirstSection().getBody().appendParagraph("")); builder.insertField(" DATE "); // Comment: Comment newComment = new Comment(docOriginal, "John Doe", "J.D.", new Date()); newComment.setText("Original comment."); builder.getCurrentParagraph().appendChild(newComment); // Header: builder.moveToHeaderFooter(HeaderFooterType.HEADER_PRIMARY); builder.writeln("Original header contents."); // Create a clone of our document and perform a quick edit on each of the cloned document's elements. Document docEdited = (Document)docOriginal.deepClone(true); Paragraph firstParagraph = docEdited.getFirstSection().getBody().getFirstParagraph(); firstParagraph.getRuns().get(0).setText("hello world! this is the first paragraph, after editing."); firstParagraph.getParagraphFormat().setStyle(docEdited.getStyles().getByStyleIdentifier(StyleIdentifier.HEADING_1)); ((Footnote)docEdited.getChild(NodeType.FOOTNOTE, 0, true)).getFirstParagraph().getRuns().get(1).setText("Edited endnote text."); ((Table)docEdited.getChild(NodeType.TABLE, 0, true)).getFirstRow().getCells().get(1).getFirstParagraph().getRuns().get(0).setText("Edited Cell 2 contents"); ((Shape)docEdited.getChild(NodeType.SHAPE, 0, true)).getFirstParagraph().getRuns().get(0).setText("Edited textbox contents"); ((FieldDate)docEdited.getRange().getFields().get(0)).setUseLunarCalendar(true); ((Comment)docEdited.getChild(NodeType.COMMENT, 0, true)).getFirstParagraph().getRuns().get(0).setText("Edited comment."); docEdited.getFirstSection().getHeadersFooters().getByHeaderFooterType(HeaderFooterType.HEADER_PRIMARY).getFirstParagraph().getRuns().get(0).setText("Edited header contents."); // Comparing documents creates a revision for every edit in the edited document. // A CompareOptions object has a series of flags that can suppress revisions // on each respective type of element, effectively ignoring their change. CompareOptions compareOptions = new CompareOptions(); compareOptions.setCompareMoves(false); compareOptions.setIgnoreFormatting(false); compareOptions.setIgnoreCaseChanges(false); compareOptions.setIgnoreComments(false); compareOptions.setIgnoreTables(false); compareOptions.setIgnoreFields(false); compareOptions.setIgnoreFootnotes(false); compareOptions.setIgnoreTextboxes(false); compareOptions.setIgnoreHeadersAndFooters(false); compareOptions.setTarget(ComparisonTargetType.NEW); docOriginal.compare(docEdited, "John Doe", new Date(), compareOptions); docOriginal.save(getArtifactsDir() + "Revision.CompareOptions.docx"); ``` **Returns:** int - The corresponding int value. The returned value is one of [ComparisonTargetType](../../com.aspose.words/comparisontargettype/) constants. ### setCompareMoves(boolean value) {#setCompareMoves-boolean} ``` public void setCompareMoves(boolean value) ``` Specifies whether to compare differences between the two documents. **Remarks:** By default move revisions are not produced. **Examples:** Shows how to filter specific types of document elements when making a comparison. ``` // Create the original document and populate it with various kinds of elements. Document docOriginal = new Document(); DocumentBuilder builder = new DocumentBuilder(docOriginal); // Paragraph text referenced with an endnote: builder.writeln("Hello world! This is the first paragraph."); builder.insertFootnote(FootnoteType.ENDNOTE, "Original endnote text."); // Table: builder.startTable(); builder.insertCell(); builder.write("Original cell 1 text"); builder.insertCell(); builder.write("Original cell 2 text"); builder.endTable(); // Textbox: Shape textBox = builder.insertShape(ShapeType.TEXT_BOX, 150.0, 20.0); builder.moveTo(textBox.getFirstParagraph()); builder.write("Original textbox contents"); // DATE field: builder.moveTo(docOriginal.getFirstSection().getBody().appendParagraph("")); builder.insertField(" DATE "); // Comment: Comment newComment = new Comment(docOriginal, "John Doe", "J.D.", new Date()); newComment.setText("Original comment."); builder.getCurrentParagraph().appendChild(newComment); // Header: builder.moveToHeaderFooter(HeaderFooterType.HEADER_PRIMARY); builder.writeln("Original header contents."); // Create a clone of our document and perform a quick edit on each of the cloned document's elements. Document docEdited = (Document)docOriginal.deepClone(true); Paragraph firstParagraph = docEdited.getFirstSection().getBody().getFirstParagraph(); firstParagraph.getRuns().get(0).setText("hello world! this is the first paragraph, after editing."); firstParagraph.getParagraphFormat().setStyle(docEdited.getStyles().getByStyleIdentifier(StyleIdentifier.HEADING_1)); ((Footnote)docEdited.getChild(NodeType.FOOTNOTE, 0, true)).getFirstParagraph().getRuns().get(1).setText("Edited endnote text."); ((Table)docEdited.getChild(NodeType.TABLE, 0, true)).getFirstRow().getCells().get(1).getFirstParagraph().getRuns().get(0).setText("Edited Cell 2 contents"); ((Shape)docEdited.getChild(NodeType.SHAPE, 0, true)).getFirstParagraph().getRuns().get(0).setText("Edited textbox contents"); ((FieldDate)docEdited.getRange().getFields().get(0)).setUseLunarCalendar(true); ((Comment)docEdited.getChild(NodeType.COMMENT, 0, true)).getFirstParagraph().getRuns().get(0).setText("Edited comment."); docEdited.getFirstSection().getHeadersFooters().getByHeaderFooterType(HeaderFooterType.HEADER_PRIMARY).getFirstParagraph().getRuns().get(0).setText("Edited header contents."); // Comparing documents creates a revision for every edit in the edited document. // A CompareOptions object has a series of flags that can suppress revisions // on each respective type of element, effectively ignoring their change. CompareOptions compareOptions = new CompareOptions(); compareOptions.setCompareMoves(false); compareOptions.setIgnoreFormatting(false); compareOptions.setIgnoreCaseChanges(false); compareOptions.setIgnoreComments(false); compareOptions.setIgnoreTables(false); compareOptions.setIgnoreFields(false); compareOptions.setIgnoreFootnotes(false); compareOptions.setIgnoreTextboxes(false); compareOptions.setIgnoreHeadersAndFooters(false); compareOptions.setTarget(ComparisonTargetType.NEW); docOriginal.compare(docEdited, "John Doe", new Date(), compareOptions); docOriginal.save(getArtifactsDir() + "Revision.CompareOptions.docx"); ``` **Parameters:** | Parameter | Type | Description | | --- | --- | --- | | value | boolean | The corresponding boolean value. | ### setGranularity(int value) {#setGranularity-int} ``` public void setGranularity(int value) ``` Specifies whether changes are tracked by character or by word. **Remarks:** Default value is [Granularity.WORD\_LEVEL](../../com.aspose.words/granularity/\#WORD-LEVEL). **Examples:** Shows to specify a granularity while comparing documents. ``` Document docA = new Document(); DocumentBuilder builderA = new DocumentBuilder(docA); builderA.writeln("Alpha Lorem ipsum dolor sit amet, consectetur adipiscing elit"); Document docB = new Document(); DocumentBuilder builderB = new DocumentBuilder(docB); builderB.writeln("Lorems ipsum dolor sit amet consectetur - \"adipiscing\" elit"); // Specify whether changes are tracking // by character ('Granularity.CharLevel'), or by word ('Granularity.WordLevel'). CompareOptions compareOptions = new CompareOptions(); compareOptions.setGranularity(granularity); docA.compare(docB, "author", new Date(), compareOptions); // The first document's collection of revision groups contains all the differences between documents. RevisionGroupCollection groups = docA.getRevisions().getGroups(); Assert.assertEquals(5, groups.getCount()); ``` **Parameters:** | Parameter | Type | Description | | --- | --- | --- | | value | int | The corresponding int value. The value must be one of [Granularity](../../com.aspose.words/granularity/) constants. | ### setIgnoreCaseChanges(boolean value) {#setIgnoreCaseChanges-boolean} ``` public void setIgnoreCaseChanges(boolean value) ``` True indicates that documents comparison is case insensitive. **Remarks:** By default comparison is case sensitive. **Examples:** Shows how to filter specific types of document elements when making a comparison. ``` // Create the original document and populate it with various kinds of elements. Document docOriginal = new Document(); DocumentBuilder builder = new DocumentBuilder(docOriginal); // Paragraph text referenced with an endnote: builder.writeln("Hello world! This is the first paragraph."); builder.insertFootnote(FootnoteType.ENDNOTE, "Original endnote text."); // Table: builder.startTable(); builder.insertCell(); builder.write("Original cell 1 text"); builder.insertCell(); builder.write("Original cell 2 text"); builder.endTable(); // Textbox: Shape textBox = builder.insertShape(ShapeType.TEXT_BOX, 150.0, 20.0); builder.moveTo(textBox.getFirstParagraph()); builder.write("Original textbox contents"); // DATE field: builder.moveTo(docOriginal.getFirstSection().getBody().appendParagraph("")); builder.insertField(" DATE "); // Comment: Comment newComment = new Comment(docOriginal, "John Doe", "J.D.", new Date()); newComment.setText("Original comment."); builder.getCurrentParagraph().appendChild(newComment); // Header: builder.moveToHeaderFooter(HeaderFooterType.HEADER_PRIMARY); builder.writeln("Original header contents."); // Create a clone of our document and perform a quick edit on each of the cloned document's elements. Document docEdited = (Document)docOriginal.deepClone(true); Paragraph firstParagraph = docEdited.getFirstSection().getBody().getFirstParagraph(); firstParagraph.getRuns().get(0).setText("hello world! this is the first paragraph, after editing."); firstParagraph.getParagraphFormat().setStyle(docEdited.getStyles().getByStyleIdentifier(StyleIdentifier.HEADING_1)); ((Footnote)docEdited.getChild(NodeType.FOOTNOTE, 0, true)).getFirstParagraph().getRuns().get(1).setText("Edited endnote text."); ((Table)docEdited.getChild(NodeType.TABLE, 0, true)).getFirstRow().getCells().get(1).getFirstParagraph().getRuns().get(0).setText("Edited Cell 2 contents"); ((Shape)docEdited.getChild(NodeType.SHAPE, 0, true)).getFirstParagraph().getRuns().get(0).setText("Edited textbox contents"); ((FieldDate)docEdited.getRange().getFields().get(0)).setUseLunarCalendar(true); ((Comment)docEdited.getChild(NodeType.COMMENT, 0, true)).getFirstParagraph().getRuns().get(0).setText("Edited comment."); docEdited.getFirstSection().getHeadersFooters().getByHeaderFooterType(HeaderFooterType.HEADER_PRIMARY).getFirstParagraph().getRuns().get(0).setText("Edited header contents."); // Comparing documents creates a revision for every edit in the edited document. // A CompareOptions object has a series of flags that can suppress revisions // on each respective type of element, effectively ignoring their change. CompareOptions compareOptions = new CompareOptions(); compareOptions.setCompareMoves(false); compareOptions.setIgnoreFormatting(false); compareOptions.setIgnoreCaseChanges(false); compareOptions.setIgnoreComments(false); compareOptions.setIgnoreTables(false); compareOptions.setIgnoreFields(false); compareOptions.setIgnoreFootnotes(false); compareOptions.setIgnoreTextboxes(false); compareOptions.setIgnoreHeadersAndFooters(false); compareOptions.setTarget(ComparisonTargetType.NEW); docOriginal.compare(docEdited, "John Doe", new Date(), compareOptions); docOriginal.save(getArtifactsDir() + "Revision.CompareOptions.docx"); ``` **Parameters:** | Parameter | Type | Description | | --- | --- | --- | | value | boolean | The corresponding boolean value. | ### setIgnoreComments(boolean value) {#setIgnoreComments-boolean} ``` public void setIgnoreComments(boolean value) ``` Specifies whether to compare differences in comments. **Remarks:** By default, comments are not ignored. **Examples:** Shows how to filter specific types of document elements when making a comparison. ``` // Create the original document and populate it with various kinds of elements. Document docOriginal = new Document(); DocumentBuilder builder = new DocumentBuilder(docOriginal); // Paragraph text referenced with an endnote: builder.writeln("Hello world! This is the first paragraph."); builder.insertFootnote(FootnoteType.ENDNOTE, "Original endnote text."); // Table: builder.startTable(); builder.insertCell(); builder.write("Original cell 1 text"); builder.insertCell(); builder.write("Original cell 2 text"); builder.endTable(); // Textbox: Shape textBox = builder.insertShape(ShapeType.TEXT_BOX, 150.0, 20.0); builder.moveTo(textBox.getFirstParagraph()); builder.write("Original textbox contents"); // DATE field: builder.moveTo(docOriginal.getFirstSection().getBody().appendParagraph("")); builder.insertField(" DATE "); // Comment: Comment newComment = new Comment(docOriginal, "John Doe", "J.D.", new Date()); newComment.setText("Original comment."); builder.getCurrentParagraph().appendChild(newComment); // Header: builder.moveToHeaderFooter(HeaderFooterType.HEADER_PRIMARY); builder.writeln("Original header contents."); // Create a clone of our document and perform a quick edit on each of the cloned document's elements. Document docEdited = (Document)docOriginal.deepClone(true); Paragraph firstParagraph = docEdited.getFirstSection().getBody().getFirstParagraph(); firstParagraph.getRuns().get(0).setText("hello world! this is the first paragraph, after editing."); firstParagraph.getParagraphFormat().setStyle(docEdited.getStyles().getByStyleIdentifier(StyleIdentifier.HEADING_1)); ((Footnote)docEdited.getChild(NodeType.FOOTNOTE, 0, true)).getFirstParagraph().getRuns().get(1).setText("Edited endnote text."); ((Table)docEdited.getChild(NodeType.TABLE, 0, true)).getFirstRow().getCells().get(1).getFirstParagraph().getRuns().get(0).setText("Edited Cell 2 contents"); ((Shape)docEdited.getChild(NodeType.SHAPE, 0, true)).getFirstParagraph().getRuns().get(0).setText("Edited textbox contents"); ((FieldDate)docEdited.getRange().getFields().get(0)).setUseLunarCalendar(true); ((Comment)docEdited.getChild(NodeType.COMMENT, 0, true)).getFirstParagraph().getRuns().get(0).setText("Edited comment."); docEdited.getFirstSection().getHeadersFooters().getByHeaderFooterType(HeaderFooterType.HEADER_PRIMARY).getFirstParagraph().getRuns().get(0).setText("Edited header contents."); // Comparing documents creates a revision for every edit in the edited document. // A CompareOptions object has a series of flags that can suppress revisions // on each respective type of element, effectively ignoring their change. CompareOptions compareOptions = new CompareOptions(); compareOptions.setCompareMoves(false); compareOptions.setIgnoreFormatting(false); compareOptions.setIgnoreCaseChanges(false); compareOptions.setIgnoreComments(false); compareOptions.setIgnoreTables(false); compareOptions.setIgnoreFields(false); compareOptions.setIgnoreFootnotes(false); compareOptions.setIgnoreTextboxes(false); compareOptions.setIgnoreHeadersAndFooters(false); compareOptions.setTarget(ComparisonTargetType.NEW); docOriginal.compare(docEdited, "John Doe", new Date(), compareOptions); docOriginal.save(getArtifactsDir() + "Revision.CompareOptions.docx"); ``` **Parameters:** | Parameter | Type | Description | | --- | --- | --- | | value | boolean | The corresponding boolean value. | ### setIgnoreDmlUniqueId(boolean value) {#setIgnoreDmlUniqueId-boolean} ``` public void setIgnoreDmlUniqueId(boolean value) ``` Specifies whether to ignore difference in DrawingML unique Id. **Remarks:** Default value is false . **Examples:** Shows how to compare documents ignoring DML unique ID. ``` Document docA = new Document(getMyDir() + "DML unique ID original.docx"); Document docB = new Document(getMyDir() + "DML unique ID compare.docx"); // By default, Aspose.Words do not ignore DML's unique ID, and the revisions count was 2. // If we are ignoring DML's unique ID, and revisions count were 0. CompareOptions compareOptions = new CompareOptions(); compareOptions.getAdvancedOptions().setIgnoreDmlUniqueId(isIgnoreDmlUniqueId); docA.compare(docB, "Aspose.Words", new Date(), compareOptions); Assert.assertEquals(isIgnoreDmlUniqueId ? 1 : 3, docA.getRevisions().getCount()); ``` **Parameters:** | Parameter | Type | Description | | --- | --- | --- | | value | boolean | The corresponding boolean value. | ### setIgnoreFields(boolean value) {#setIgnoreFields-boolean} ``` public void setIgnoreFields(boolean value) ``` Specifies whether to compare differences in fields. **Remarks:** By default fields are not ignored. **Examples:** Shows how to filter specific types of document elements when making a comparison. ``` // Create the original document and populate it with various kinds of elements. Document docOriginal = new Document(); DocumentBuilder builder = new DocumentBuilder(docOriginal); // Paragraph text referenced with an endnote: builder.writeln("Hello world! This is the first paragraph."); builder.insertFootnote(FootnoteType.ENDNOTE, "Original endnote text."); // Table: builder.startTable(); builder.insertCell(); builder.write("Original cell 1 text"); builder.insertCell(); builder.write("Original cell 2 text"); builder.endTable(); // Textbox: Shape textBox = builder.insertShape(ShapeType.TEXT_BOX, 150.0, 20.0); builder.moveTo(textBox.getFirstParagraph()); builder.write("Original textbox contents"); // DATE field: builder.moveTo(docOriginal.getFirstSection().getBody().appendParagraph("")); builder.insertField(" DATE "); // Comment: Comment newComment = new Comment(docOriginal, "John Doe", "J.D.", new Date()); newComment.setText("Original comment."); builder.getCurrentParagraph().appendChild(newComment); // Header: builder.moveToHeaderFooter(HeaderFooterType.HEADER_PRIMARY); builder.writeln("Original header contents."); // Create a clone of our document and perform a quick edit on each of the cloned document's elements. Document docEdited = (Document)docOriginal.deepClone(true); Paragraph firstParagraph = docEdited.getFirstSection().getBody().getFirstParagraph(); firstParagraph.getRuns().get(0).setText("hello world! this is the first paragraph, after editing."); firstParagraph.getParagraphFormat().setStyle(docEdited.getStyles().getByStyleIdentifier(StyleIdentifier.HEADING_1)); ((Footnote)docEdited.getChild(NodeType.FOOTNOTE, 0, true)).getFirstParagraph().getRuns().get(1).setText("Edited endnote text."); ((Table)docEdited.getChild(NodeType.TABLE, 0, true)).getFirstRow().getCells().get(1).getFirstParagraph().getRuns().get(0).setText("Edited Cell 2 contents"); ((Shape)docEdited.getChild(NodeType.SHAPE, 0, true)).getFirstParagraph().getRuns().get(0).setText("Edited textbox contents"); ((FieldDate)docEdited.getRange().getFields().get(0)).setUseLunarCalendar(true); ((Comment)docEdited.getChild(NodeType.COMMENT, 0, true)).getFirstParagraph().getRuns().get(0).setText("Edited comment."); docEdited.getFirstSection().getHeadersFooters().getByHeaderFooterType(HeaderFooterType.HEADER_PRIMARY).getFirstParagraph().getRuns().get(0).setText("Edited header contents."); // Comparing documents creates a revision for every edit in the edited document. // A CompareOptions object has a series of flags that can suppress revisions // on each respective type of element, effectively ignoring their change. CompareOptions compareOptions = new CompareOptions(); compareOptions.setCompareMoves(false); compareOptions.setIgnoreFormatting(false); compareOptions.setIgnoreCaseChanges(false); compareOptions.setIgnoreComments(false); compareOptions.setIgnoreTables(false); compareOptions.setIgnoreFields(false); compareOptions.setIgnoreFootnotes(false); compareOptions.setIgnoreTextboxes(false); compareOptions.setIgnoreHeadersAndFooters(false); compareOptions.setTarget(ComparisonTargetType.NEW); docOriginal.compare(docEdited, "John Doe", new Date(), compareOptions); docOriginal.save(getArtifactsDir() + "Revision.CompareOptions.docx"); ``` **Parameters:** | Parameter | Type | Description | | --- | --- | --- | | value | boolean | The corresponding boolean value. | ### setIgnoreFootnotes(boolean value) {#setIgnoreFootnotes-boolean} ``` public void setIgnoreFootnotes(boolean value) ``` Specifies whether to compare differences in footnotes and endnotes. **Remarks:** By default, footnotes are not ignored. **Examples:** Shows how to filter specific types of document elements when making a comparison. ``` // Create the original document and populate it with various kinds of elements. Document docOriginal = new Document(); DocumentBuilder builder = new DocumentBuilder(docOriginal); // Paragraph text referenced with an endnote: builder.writeln("Hello world! This is the first paragraph."); builder.insertFootnote(FootnoteType.ENDNOTE, "Original endnote text."); // Table: builder.startTable(); builder.insertCell(); builder.write("Original cell 1 text"); builder.insertCell(); builder.write("Original cell 2 text"); builder.endTable(); // Textbox: Shape textBox = builder.insertShape(ShapeType.TEXT_BOX, 150.0, 20.0); builder.moveTo(textBox.getFirstParagraph()); builder.write("Original textbox contents"); // DATE field: builder.moveTo(docOriginal.getFirstSection().getBody().appendParagraph("")); builder.insertField(" DATE "); // Comment: Comment newComment = new Comment(docOriginal, "John Doe", "J.D.", new Date()); newComment.setText("Original comment."); builder.getCurrentParagraph().appendChild(newComment); // Header: builder.moveToHeaderFooter(HeaderFooterType.HEADER_PRIMARY); builder.writeln("Original header contents."); // Create a clone of our document and perform a quick edit on each of the cloned document's elements. Document docEdited = (Document)docOriginal.deepClone(true); Paragraph firstParagraph = docEdited.getFirstSection().getBody().getFirstParagraph(); firstParagraph.getRuns().get(0).setText("hello world! this is the first paragraph, after editing."); firstParagraph.getParagraphFormat().setStyle(docEdited.getStyles().getByStyleIdentifier(StyleIdentifier.HEADING_1)); ((Footnote)docEdited.getChild(NodeType.FOOTNOTE, 0, true)).getFirstParagraph().getRuns().get(1).setText("Edited endnote text."); ((Table)docEdited.getChild(NodeType.TABLE, 0, true)).getFirstRow().getCells().get(1).getFirstParagraph().getRuns().get(0).setText("Edited Cell 2 contents"); ((Shape)docEdited.getChild(NodeType.SHAPE, 0, true)).getFirstParagraph().getRuns().get(0).setText("Edited textbox contents"); ((FieldDate)docEdited.getRange().getFields().get(0)).setUseLunarCalendar(true); ((Comment)docEdited.getChild(NodeType.COMMENT, 0, true)).getFirstParagraph().getRuns().get(0).setText("Edited comment."); docEdited.getFirstSection().getHeadersFooters().getByHeaderFooterType(HeaderFooterType.HEADER_PRIMARY).getFirstParagraph().getRuns().get(0).setText("Edited header contents."); // Comparing documents creates a revision for every edit in the edited document. // A CompareOptions object has a series of flags that can suppress revisions // on each respective type of element, effectively ignoring their change. CompareOptions compareOptions = new CompareOptions(); compareOptions.setCompareMoves(false); compareOptions.setIgnoreFormatting(false); compareOptions.setIgnoreCaseChanges(false); compareOptions.setIgnoreComments(false); compareOptions.setIgnoreTables(false); compareOptions.setIgnoreFields(false); compareOptions.setIgnoreFootnotes(false); compareOptions.setIgnoreTextboxes(false); compareOptions.setIgnoreHeadersAndFooters(false); compareOptions.setTarget(ComparisonTargetType.NEW); docOriginal.compare(docEdited, "John Doe", new Date(), compareOptions); docOriginal.save(getArtifactsDir() + "Revision.CompareOptions.docx"); ``` **Parameters:** | Parameter | Type | Description | | --- | --- | --- | | value | boolean | The corresponding boolean value. | ### setIgnoreFormatting(boolean value) {#setIgnoreFormatting-boolean} ``` public void setIgnoreFormatting(boolean value) ``` True indicates that formatting is ignored. **Remarks:** By default, document formatting is not ignored. **Examples:** Shows how to filter specific types of document elements when making a comparison. ``` // Create the original document and populate it with various kinds of elements. Document docOriginal = new Document(); DocumentBuilder builder = new DocumentBuilder(docOriginal); // Paragraph text referenced with an endnote: builder.writeln("Hello world! This is the first paragraph."); builder.insertFootnote(FootnoteType.ENDNOTE, "Original endnote text."); // Table: builder.startTable(); builder.insertCell(); builder.write("Original cell 1 text"); builder.insertCell(); builder.write("Original cell 2 text"); builder.endTable(); // Textbox: Shape textBox = builder.insertShape(ShapeType.TEXT_BOX, 150.0, 20.0); builder.moveTo(textBox.getFirstParagraph()); builder.write("Original textbox contents"); // DATE field: builder.moveTo(docOriginal.getFirstSection().getBody().appendParagraph("")); builder.insertField(" DATE "); // Comment: Comment newComment = new Comment(docOriginal, "John Doe", "J.D.", new Date()); newComment.setText("Original comment."); builder.getCurrentParagraph().appendChild(newComment); // Header: builder.moveToHeaderFooter(HeaderFooterType.HEADER_PRIMARY); builder.writeln("Original header contents."); // Create a clone of our document and perform a quick edit on each of the cloned document's elements. Document docEdited = (Document)docOriginal.deepClone(true); Paragraph firstParagraph = docEdited.getFirstSection().getBody().getFirstParagraph(); firstParagraph.getRuns().get(0).setText("hello world! this is the first paragraph, after editing."); firstParagraph.getParagraphFormat().setStyle(docEdited.getStyles().getByStyleIdentifier(StyleIdentifier.HEADING_1)); ((Footnote)docEdited.getChild(NodeType.FOOTNOTE, 0, true)).getFirstParagraph().getRuns().get(1).setText("Edited endnote text."); ((Table)docEdited.getChild(NodeType.TABLE, 0, true)).getFirstRow().getCells().get(1).getFirstParagraph().getRuns().get(0).setText("Edited Cell 2 contents"); ((Shape)docEdited.getChild(NodeType.SHAPE, 0, true)).getFirstParagraph().getRuns().get(0).setText("Edited textbox contents"); ((FieldDate)docEdited.getRange().getFields().get(0)).setUseLunarCalendar(true); ((Comment)docEdited.getChild(NodeType.COMMENT, 0, true)).getFirstParagraph().getRuns().get(0).setText("Edited comment."); docEdited.getFirstSection().getHeadersFooters().getByHeaderFooterType(HeaderFooterType.HEADER_PRIMARY).getFirstParagraph().getRuns().get(0).setText("Edited header contents."); // Comparing documents creates a revision for every edit in the edited document. // A CompareOptions object has a series of flags that can suppress revisions // on each respective type of element, effectively ignoring their change. CompareOptions compareOptions = new CompareOptions(); compareOptions.setCompareMoves(false); compareOptions.setIgnoreFormatting(false); compareOptions.setIgnoreCaseChanges(false); compareOptions.setIgnoreComments(false); compareOptions.setIgnoreTables(false); compareOptions.setIgnoreFields(false); compareOptions.setIgnoreFootnotes(false); compareOptions.setIgnoreTextboxes(false); compareOptions.setIgnoreHeadersAndFooters(false); compareOptions.setTarget(ComparisonTargetType.NEW); docOriginal.compare(docEdited, "John Doe", new Date(), compareOptions); docOriginal.save(getArtifactsDir() + "Revision.CompareOptions.docx"); ``` **Parameters:** | Parameter | Type | Description | | --- | --- | --- | | value | boolean | The corresponding boolean value. | ### setIgnoreHeadersAndFooters(boolean value) {#setIgnoreHeadersAndFooters-boolean} ``` public void setIgnoreHeadersAndFooters(boolean value) ``` True indicates that headers and footers content is ignored. **Remarks:** By default, headers and footers are not ignored. **Examples:** Shows how to filter specific types of document elements when making a comparison. ``` // Create the original document and populate it with various kinds of elements. Document docOriginal = new Document(); DocumentBuilder builder = new DocumentBuilder(docOriginal); // Paragraph text referenced with an endnote: builder.writeln("Hello world! This is the first paragraph."); builder.insertFootnote(FootnoteType.ENDNOTE, "Original endnote text."); // Table: builder.startTable(); builder.insertCell(); builder.write("Original cell 1 text"); builder.insertCell(); builder.write("Original cell 2 text"); builder.endTable(); // Textbox: Shape textBox = builder.insertShape(ShapeType.TEXT_BOX, 150.0, 20.0); builder.moveTo(textBox.getFirstParagraph()); builder.write("Original textbox contents"); // DATE field: builder.moveTo(docOriginal.getFirstSection().getBody().appendParagraph("")); builder.insertField(" DATE "); // Comment: Comment newComment = new Comment(docOriginal, "John Doe", "J.D.", new Date()); newComment.setText("Original comment."); builder.getCurrentParagraph().appendChild(newComment); // Header: builder.moveToHeaderFooter(HeaderFooterType.HEADER_PRIMARY); builder.writeln("Original header contents."); // Create a clone of our document and perform a quick edit on each of the cloned document's elements. Document docEdited = (Document)docOriginal.deepClone(true); Paragraph firstParagraph = docEdited.getFirstSection().getBody().getFirstParagraph(); firstParagraph.getRuns().get(0).setText("hello world! this is the first paragraph, after editing."); firstParagraph.getParagraphFormat().setStyle(docEdited.getStyles().getByStyleIdentifier(StyleIdentifier.HEADING_1)); ((Footnote)docEdited.getChild(NodeType.FOOTNOTE, 0, true)).getFirstParagraph().getRuns().get(1).setText("Edited endnote text."); ((Table)docEdited.getChild(NodeType.TABLE, 0, true)).getFirstRow().getCells().get(1).getFirstParagraph().getRuns().get(0).setText("Edited Cell 2 contents"); ((Shape)docEdited.getChild(NodeType.SHAPE, 0, true)).getFirstParagraph().getRuns().get(0).setText("Edited textbox contents"); ((FieldDate)docEdited.getRange().getFields().get(0)).setUseLunarCalendar(true); ((Comment)docEdited.getChild(NodeType.COMMENT, 0, true)).getFirstParagraph().getRuns().get(0).setText("Edited comment."); docEdited.getFirstSection().getHeadersFooters().getByHeaderFooterType(HeaderFooterType.HEADER_PRIMARY).getFirstParagraph().getRuns().get(0).setText("Edited header contents."); // Comparing documents creates a revision for every edit in the edited document. // A CompareOptions object has a series of flags that can suppress revisions // on each respective type of element, effectively ignoring their change. CompareOptions compareOptions = new CompareOptions(); compareOptions.setCompareMoves(false); compareOptions.setIgnoreFormatting(false); compareOptions.setIgnoreCaseChanges(false); compareOptions.setIgnoreComments(false); compareOptions.setIgnoreTables(false); compareOptions.setIgnoreFields(false); compareOptions.setIgnoreFootnotes(false); compareOptions.setIgnoreTextboxes(false); compareOptions.setIgnoreHeadersAndFooters(false); compareOptions.setTarget(ComparisonTargetType.NEW); docOriginal.compare(docEdited, "John Doe", new Date(), compareOptions); docOriginal.save(getArtifactsDir() + "Revision.CompareOptions.docx"); ``` **Parameters:** | Parameter | Type | Description | | --- | --- | --- | | value | boolean | The corresponding boolean value. | ### setIgnoreTables(boolean value) {#setIgnoreTables-boolean} ``` public void setIgnoreTables(boolean value) ``` Specifies whether to compare the differences in data contained in tables. **Remarks:** By default tables are not ignored. **Examples:** Shows how to filter specific types of document elements when making a comparison. ``` // Create the original document and populate it with various kinds of elements. Document docOriginal = new Document(); DocumentBuilder builder = new DocumentBuilder(docOriginal); // Paragraph text referenced with an endnote: builder.writeln("Hello world! This is the first paragraph."); builder.insertFootnote(FootnoteType.ENDNOTE, "Original endnote text."); // Table: builder.startTable(); builder.insertCell(); builder.write("Original cell 1 text"); builder.insertCell(); builder.write("Original cell 2 text"); builder.endTable(); // Textbox: Shape textBox = builder.insertShape(ShapeType.TEXT_BOX, 150.0, 20.0); builder.moveTo(textBox.getFirstParagraph()); builder.write("Original textbox contents"); // DATE field: builder.moveTo(docOriginal.getFirstSection().getBody().appendParagraph("")); builder.insertField(" DATE "); // Comment: Comment newComment = new Comment(docOriginal, "John Doe", "J.D.", new Date()); newComment.setText("Original comment."); builder.getCurrentParagraph().appendChild(newComment); // Header: builder.moveToHeaderFooter(HeaderFooterType.HEADER_PRIMARY); builder.writeln("Original header contents."); // Create a clone of our document and perform a quick edit on each of the cloned document's elements. Document docEdited = (Document)docOriginal.deepClone(true); Paragraph firstParagraph = docEdited.getFirstSection().getBody().getFirstParagraph(); firstParagraph.getRuns().get(0).setText("hello world! this is the first paragraph, after editing."); firstParagraph.getParagraphFormat().setStyle(docEdited.getStyles().getByStyleIdentifier(StyleIdentifier.HEADING_1)); ((Footnote)docEdited.getChild(NodeType.FOOTNOTE, 0, true)).getFirstParagraph().getRuns().get(1).setText("Edited endnote text."); ((Table)docEdited.getChild(NodeType.TABLE, 0, true)).getFirstRow().getCells().get(1).getFirstParagraph().getRuns().get(0).setText("Edited Cell 2 contents"); ((Shape)docEdited.getChild(NodeType.SHAPE, 0, true)).getFirstParagraph().getRuns().get(0).setText("Edited textbox contents"); ((FieldDate)docEdited.getRange().getFields().get(0)).setUseLunarCalendar(true); ((Comment)docEdited.getChild(NodeType.COMMENT, 0, true)).getFirstParagraph().getRuns().get(0).setText("Edited comment."); docEdited.getFirstSection().getHeadersFooters().getByHeaderFooterType(HeaderFooterType.HEADER_PRIMARY).getFirstParagraph().getRuns().get(0).setText("Edited header contents."); // Comparing documents creates a revision for every edit in the edited document. // A CompareOptions object has a series of flags that can suppress revisions // on each respective type of element, effectively ignoring their change. CompareOptions compareOptions = new CompareOptions(); compareOptions.setCompareMoves(false); compareOptions.setIgnoreFormatting(false); compareOptions.setIgnoreCaseChanges(false); compareOptions.setIgnoreComments(false); compareOptions.setIgnoreTables(false); compareOptions.setIgnoreFields(false); compareOptions.setIgnoreFootnotes(false); compareOptions.setIgnoreTextboxes(false); compareOptions.setIgnoreHeadersAndFooters(false); compareOptions.setTarget(ComparisonTargetType.NEW); docOriginal.compare(docEdited, "John Doe", new Date(), compareOptions); docOriginal.save(getArtifactsDir() + "Revision.CompareOptions.docx"); ``` **Parameters:** | Parameter | Type | Description | | --- | --- | --- | | value | boolean | The corresponding boolean value. | ### setIgnoreTextboxes(boolean value) {#setIgnoreTextboxes-boolean} ``` public void setIgnoreTextboxes(boolean value) ``` Specifies whether to compare differences in the data contained within text boxes. **Remarks:** By default, textboxes are not ignored. **Examples:** Shows how to filter specific types of document elements when making a comparison. ``` // Create the original document and populate it with various kinds of elements. Document docOriginal = new Document(); DocumentBuilder builder = new DocumentBuilder(docOriginal); // Paragraph text referenced with an endnote: builder.writeln("Hello world! This is the first paragraph."); builder.insertFootnote(FootnoteType.ENDNOTE, "Original endnote text."); // Table: builder.startTable(); builder.insertCell(); builder.write("Original cell 1 text"); builder.insertCell(); builder.write("Original cell 2 text"); builder.endTable(); // Textbox: Shape textBox = builder.insertShape(ShapeType.TEXT_BOX, 150.0, 20.0); builder.moveTo(textBox.getFirstParagraph()); builder.write("Original textbox contents"); // DATE field: builder.moveTo(docOriginal.getFirstSection().getBody().appendParagraph("")); builder.insertField(" DATE "); // Comment: Comment newComment = new Comment(docOriginal, "John Doe", "J.D.", new Date()); newComment.setText("Original comment."); builder.getCurrentParagraph().appendChild(newComment); // Header: builder.moveToHeaderFooter(HeaderFooterType.HEADER_PRIMARY); builder.writeln("Original header contents."); // Create a clone of our document and perform a quick edit on each of the cloned document's elements. Document docEdited = (Document)docOriginal.deepClone(true); Paragraph firstParagraph = docEdited.getFirstSection().getBody().getFirstParagraph(); firstParagraph.getRuns().get(0).setText("hello world! this is the first paragraph, after editing."); firstParagraph.getParagraphFormat().setStyle(docEdited.getStyles().getByStyleIdentifier(StyleIdentifier.HEADING_1)); ((Footnote)docEdited.getChild(NodeType.FOOTNOTE, 0, true)).getFirstParagraph().getRuns().get(1).setText("Edited endnote text."); ((Table)docEdited.getChild(NodeType.TABLE, 0, true)).getFirstRow().getCells().get(1).getFirstParagraph().getRuns().get(0).setText("Edited Cell 2 contents"); ((Shape)docEdited.getChild(NodeType.SHAPE, 0, true)).getFirstParagraph().getRuns().get(0).setText("Edited textbox contents"); ((FieldDate)docEdited.getRange().getFields().get(0)).setUseLunarCalendar(true); ((Comment)docEdited.getChild(NodeType.COMMENT, 0, true)).getFirstParagraph().getRuns().get(0).setText("Edited comment."); docEdited.getFirstSection().getHeadersFooters().getByHeaderFooterType(HeaderFooterType.HEADER_PRIMARY).getFirstParagraph().getRuns().get(0).setText("Edited header contents."); // Comparing documents creates a revision for every edit in the edited document. // A CompareOptions object has a series of flags that can suppress revisions // on each respective type of element, effectively ignoring their change. CompareOptions compareOptions = new CompareOptions(); compareOptions.setCompareMoves(false); compareOptions.setIgnoreFormatting(false); compareOptions.setIgnoreCaseChanges(false); compareOptions.setIgnoreComments(false); compareOptions.setIgnoreTables(false); compareOptions.setIgnoreFields(false); compareOptions.setIgnoreFootnotes(false); compareOptions.setIgnoreTextboxes(false); compareOptions.setIgnoreHeadersAndFooters(false); compareOptions.setTarget(ComparisonTargetType.NEW); docOriginal.compare(docEdited, "John Doe", new Date(), compareOptions); docOriginal.save(getArtifactsDir() + "Revision.CompareOptions.docx"); ``` **Parameters:** | Parameter | Type | Description | | --- | --- | --- | | value | boolean | The corresponding boolean value. | ### setTarget(int value) {#setTarget-int} ``` public void setTarget(int value) ``` Specifies which document shall be used as a target during comparison. **Examples:** Shows how to filter specific types of document elements when making a comparison. ``` // Create the original document and populate it with various kinds of elements. Document docOriginal = new Document(); DocumentBuilder builder = new DocumentBuilder(docOriginal); // Paragraph text referenced with an endnote: builder.writeln("Hello world! This is the first paragraph."); builder.insertFootnote(FootnoteType.ENDNOTE, "Original endnote text."); // Table: builder.startTable(); builder.insertCell(); builder.write("Original cell 1 text"); builder.insertCell(); builder.write("Original cell 2 text"); builder.endTable(); // Textbox: Shape textBox = builder.insertShape(ShapeType.TEXT_BOX, 150.0, 20.0); builder.moveTo(textBox.getFirstParagraph()); builder.write("Original textbox contents"); // DATE field: builder.moveTo(docOriginal.getFirstSection().getBody().appendParagraph("")); builder.insertField(" DATE "); // Comment: Comment newComment = new Comment(docOriginal, "John Doe", "J.D.", new Date()); newComment.setText("Original comment."); builder.getCurrentParagraph().appendChild(newComment); // Header: builder.moveToHeaderFooter(HeaderFooterType.HEADER_PRIMARY); builder.writeln("Original header contents."); // Create a clone of our document and perform a quick edit on each of the cloned document's elements. Document docEdited = (Document)docOriginal.deepClone(true); Paragraph firstParagraph = docEdited.getFirstSection().getBody().getFirstParagraph(); firstParagraph.getRuns().get(0).setText("hello world! this is the first paragraph, after editing."); firstParagraph.getParagraphFormat().setStyle(docEdited.getStyles().getByStyleIdentifier(StyleIdentifier.HEADING_1)); ((Footnote)docEdited.getChild(NodeType.FOOTNOTE, 0, true)).getFirstParagraph().getRuns().get(1).setText("Edited endnote text."); ((Table)docEdited.getChild(NodeType.TABLE, 0, true)).getFirstRow().getCells().get(1).getFirstParagraph().getRuns().get(0).setText("Edited Cell 2 contents"); ((Shape)docEdited.getChild(NodeType.SHAPE, 0, true)).getFirstParagraph().getRuns().get(0).setText("Edited textbox contents"); ((FieldDate)docEdited.getRange().getFields().get(0)).setUseLunarCalendar(true); ((Comment)docEdited.getChild(NodeType.COMMENT, 0, true)).getFirstParagraph().getRuns().get(0).setText("Edited comment."); docEdited.getFirstSection().getHeadersFooters().getByHeaderFooterType(HeaderFooterType.HEADER_PRIMARY).getFirstParagraph().getRuns().get(0).setText("Edited header contents."); // Comparing documents creates a revision for every edit in the edited document. // A CompareOptions object has a series of flags that can suppress revisions // on each respective type of element, effectively ignoring their change. CompareOptions compareOptions = new CompareOptions(); compareOptions.setCompareMoves(false); compareOptions.setIgnoreFormatting(false); compareOptions.setIgnoreCaseChanges(false); compareOptions.setIgnoreComments(false); compareOptions.setIgnoreTables(false); compareOptions.setIgnoreFields(false); compareOptions.setIgnoreFootnotes(false); compareOptions.setIgnoreTextboxes(false); compareOptions.setIgnoreHeadersAndFooters(false); compareOptions.setTarget(ComparisonTargetType.NEW); docOriginal.compare(docEdited, "John Doe", new Date(), compareOptions); docOriginal.save(getArtifactsDir() + "Revision.CompareOptions.docx"); ``` **Parameters:** | Parameter | Type | Description | | --- | --- | --- | | value | int | The corresponding int value. The value must be one of [ComparisonTargetType](../../com.aspose.words/comparisontargettype/) constants. |