com.aspose.words

Property Getters/Setters Detail

• getCustomNodeId/setCustomNodeId

  public int getCustomNodeId() / public void setCustomNodeId(int value)
  

  Specifies custom node identifier.

  Default is zero.

  This identifier can be set and used arbitrarily. For example, as a key to get external data.

  Important note, specified value is not saved to an output file and exists only during the node lifetime.

  Example:

  Shows how to traverse through a composite node's collection of child nodes.

  Document doc = new Document();
  
  // Add two runs and one shape as child nodes to the first paragraph of this document.
  Paragraph paragraph = (Paragraph) doc.getChild(NodeType.PARAGRAPH, 0, true);
  paragraph.appendChild(new Run(doc, "Hello world! "));
  
  Shape shape = new Shape(doc, ShapeType.RECTANGLE);
  shape.setWidth(200.0);
  shape.setHeight(200.0);
  // Note that the 'CustomNodeId' is not saved to an output file and exists only during the node lifetime.
  shape.setCustomNodeId(100);
  shape.setWrapType(WrapType.INLINE);
  paragraph.appendChild(shape);
  
  paragraph.appendChild(new Run(doc, "Hello again!"));
  
  // Iterate through the paragraph's collection of immediate children,
  // and print any runs or shapes that we find within.
  NodeCollection children = paragraph.getChildNodes();
  
  Assert.assertEquals(3, paragraph.getChildNodes().getCount());
  
  for (Node child : (Iterable<Node>) children)
      switch (child.getNodeType()) {
          case NodeType.RUN:
              System.out.println("Run contents:");
              System.out.println("\t\"{child.GetText().Trim()}\"");
              break;
          case NodeType.SHAPE:
              Shape childShape = (Shape) child;
              System.out.println("Shape:");
              System.out.println("\t{childShape.ShapeType}, {childShape.Width}x{childShape.Height}");
      }

• getDocument

  public DocumentBase getDocument()
  

  Gets the document to which this node belongs.

  The node always belongs to a document even if it has just been created and not yet added to the tree, or if it has been removed from the tree.

  Example:

  Shows how to create a node and set its owning document.

  Document doc = new Document();
  Paragraph para = new Paragraph(doc);
  para.appendChild(new Run(doc, "Hello world!"));
  
  // We have not yet appended this paragraph as a child to any composite node.
  Assert.assertNull(para.getParentNode());
  
  // If a node is an appropriate child node type of another composite node,
  // we can attach it as a child only if both nodes have the same owner document.
  // The owner document is the document we passed to the node's constructor.
  // We have not attached this paragraph to the document, so the document does not contain its text.
  Assert.assertEquals(para.getDocument(), doc);
  Assert.assertEquals("", doc.getText().trim());
  
  // Since the document owns this paragraph, we can apply one of its styles to the paragraph's contents.
  para.getParagraphFormat().setStyleName("Heading 1");
  
  // Add this node to the document, and then verify its contents.
  doc.getFirstSection().getBody().appendChild(para);
  
  Assert.assertEquals(doc.getFirstSection().getBody(), para.getParentNode());
  Assert.assertEquals("Hello world!", doc.getText().trim());

• getFont

  public Font getFont()
  

  Provides access to the font formatting of this object.

  Example:

  Shows how to construct an Aspose.Words document by hand.

  Document doc = new Document();
  
  // A blank document contains one section, one body and one paragraph.
  // Call the "RemoveAllChildren" method to remove all those nodes,
  // and end up with a document node with no children.
  doc.removeAllChildren();
  
  // This document now has no composite child nodes that we can add content to.
  // If we wish to edit it, we will need to repopulate its node collection.
  // First, create a new section, and then append it as a child to the root document node.
  Section section = new Section(doc);
  doc.appendChild(section);
  
  // Set some page setup properties for the section.
  section.getPageSetup().setSectionStart(SectionStart.NEW_PAGE);
  section.getPageSetup().setPaperSize(PaperSize.LETTER);
  
  // A section needs a body, which will contain and display all its contents
  // on the page between the section's header and footer.
  Body body = new Body(doc);
  section.appendChild(body);
  
  // Create a paragraph, set some formatting properties, and then append it as a child to the body.
  Paragraph para = new Paragraph(doc);
  
  para.getParagraphFormat().setStyleName("Heading 1");
  para.getParagraphFormat().setAlignment(ParagraphAlignment.CENTER);
  
  body.appendChild(para);
  
  // Finally, add some content to do the document. Create a run,
  // set its appearance and contents, and then append it as a child to the paragraph.
  Run run = new Run(doc);
  run.setText("Hello World!");
  run.getFont().setColor(Color.RED);
  para.appendChild(run);
  
  Assert.assertEquals("Hello World!", doc.getText().trim());
  
  doc.save(getArtifactsDir() + "Section.CreateManually.docx");

• isComposite

  public boolean isComposite()
  

  Returns true if this node can contain other nodes.

  This method returns false as Node cannot have child nodes.

  Example:

  Shows how to traverse a composite node's tree of child nodes.

  Document doc = new Document(getMyDir() + "Paragraphs.docx");
  
      // Any node that can contain child nodes, such as the document itself, is composite.
      Assert.assertTrue(doc.isComposite());
  
      // Invoke the recursive function that will go through and print all the child nodes of a composite node.
      traverseAllNodes(doc, 0);
  }
  
  /// <summary>
  /// Recursively traverses a node tree while printing the type of each node
  /// with an indent depending on depth as well as the contents of all inline nodes.
  /// </summary>
  @Test(enabled = false)
  public void traverseAllNodes(CompositeNode parentNode, int depth) {
      for (Node childNode = parentNode.getFirstChild(); childNode != null; childNode = childNode.getNextSibling()) {
          System.out.println(MessageFormat.format("{0}{1}", String.format("    ", depth), Node.nodeTypeToString(childNode.getNodeType())));
  
          // Recurse into the node if it is a composite node. Otherwise, print its contents if it is an inline node.
          if (childNode.isComposite()) {
              System.out.println();
              traverseAllNodes((CompositeNode) childNode, depth + 1);
          } else if (childNode instanceof Inline) {
              System.out.println(" - \"{childNode.GetText().Trim()}\"");
          } else {
              System.out.println();
          }
      }
  }

• isDeleteRevision

  public boolean isDeleteRevision()
  

  Returns true if this object was deleted in Microsoft Word while change tracking was enabled.

  Example:

  Shows how to determine the revision type of an inline node.

  Document doc = new Document(getMyDir() + "Revision runs.docx");
  
  // When we edit the document while the "Track Changes" option, found in via Review -> Tracking,
  // is turned on in Microsoft Word, the changes we apply count as revisions.
  // When editing a document using Aspose.Words, we can begin tracking revisions by
  // invoking the document's "StartTrackRevisions" method and stop tracking by using the "StopTrackRevisions" method.
  // We can either accept revisions to assimilate them into the document
  // or reject them to change the proposed change effectively.
  Assert.assertEquals(6, doc.getRevisions().getCount());
  
  // The parent node of a revision is the run that the revision concerns. A Run is an Inline node.
  Run run = (Run) doc.getRevisions().get(0).getParentNode();
  
  Paragraph firstParagraph = run.getParentParagraph();
  RunCollection runs = firstParagraph.getRuns();
  
  Assert.assertEquals(runs.getCount(), 6);
  
  // Below are five types of revisions that can flag an Inline node.
  // 1 -  An "insert" revision:
  // This revision occurs when we insert text while tracking changes.
  Assert.assertTrue(runs.get(2).isInsertRevision());
  
  // 2 -  A "format" revision:
  // This revision occurs when we change the formatting of text while tracking changes.
  Assert.assertTrue(runs.get(2).isFormatRevision());
  
  // 3 -  A "move from" revision:
  // When we highlight text in Microsoft Word, and then drag it to a different place in the document
  // while tracking changes, two revisions appear.
  // The "move from" revision is a copy of the text originally before we moved it.
  Assert.assertTrue(runs.get(4).isMoveFromRevision());
  
  // 4 -  A "move to" revision:
  // The "move to" revision is the text that we moved in its new position in the document.
  // "Move from" and "move to" revisions appear in pairs for every move revision we carry out.
  // Accepting a move revision deletes the "move from" revision and its text,
  // and keeps the text from the "move to" revision.
  // Rejecting a move revision conversely keeps the "move from" revision and deletes the "move to" revision.
  Assert.assertTrue(runs.get(1).isMoveToRevision());
  
  // 5 -  A "delete" revision:
  // This revision occurs when we delete text while tracking changes. When we delete text like this,
  // it will stay in the document as a revision until we either accept the revision,
  // which will delete the text for good, or reject the revision, which will keep the text we deleted where it was.
  Assert.assertTrue(runs.get(5).isDeleteRevision());

• isFormatRevision

  public boolean isFormatRevision()
  

  Returns true if formatting of the object was changed in Microsoft Word while change tracking was enabled.

  Example:

  Shows how to determine the revision type of an inline node.

  Document doc = new Document(getMyDir() + "Revision runs.docx");
  
  // When we edit the document while the "Track Changes" option, found in via Review -> Tracking,
  // is turned on in Microsoft Word, the changes we apply count as revisions.
  // When editing a document using Aspose.Words, we can begin tracking revisions by
  // invoking the document's "StartTrackRevisions" method and stop tracking by using the "StopTrackRevisions" method.
  // We can either accept revisions to assimilate them into the document
  // or reject them to change the proposed change effectively.
  Assert.assertEquals(6, doc.getRevisions().getCount());
  
  // The parent node of a revision is the run that the revision concerns. A Run is an Inline node.
  Run run = (Run) doc.getRevisions().get(0).getParentNode();
  
  Paragraph firstParagraph = run.getParentParagraph();
  RunCollection runs = firstParagraph.getRuns();
  
  Assert.assertEquals(runs.getCount(), 6);
  
  // Below are five types of revisions that can flag an Inline node.
  // 1 -  An "insert" revision:
  // This revision occurs when we insert text while tracking changes.
  Assert.assertTrue(runs.get(2).isInsertRevision());
  
  // 2 -  A "format" revision:
  // This revision occurs when we change the formatting of text while tracking changes.
  Assert.assertTrue(runs.get(2).isFormatRevision());
  
  // 3 -  A "move from" revision:
  // When we highlight text in Microsoft Word, and then drag it to a different place in the document
  // while tracking changes, two revisions appear.
  // The "move from" revision is a copy of the text originally before we moved it.
  Assert.assertTrue(runs.get(4).isMoveFromRevision());
  
  // 4 -  A "move to" revision:
  // The "move to" revision is the text that we moved in its new position in the document.
  // "Move from" and "move to" revisions appear in pairs for every move revision we carry out.
  // Accepting a move revision deletes the "move from" revision and its text,
  // and keeps the text from the "move to" revision.
  // Rejecting a move revision conversely keeps the "move from" revision and deletes the "move to" revision.
  Assert.assertTrue(runs.get(1).isMoveToRevision());
  
  // 5 -  A "delete" revision:
  // This revision occurs when we delete text while tracking changes. When we delete text like this,
  // it will stay in the document as a revision until we either accept the revision,
  // which will delete the text for good, or reject the revision, which will keep the text we deleted where it was.
  Assert.assertTrue(runs.get(5).isDeleteRevision());

• isInsertRevision

  public boolean isInsertRevision()
  

  Returns true if this object was inserted in Microsoft Word while change tracking was enabled.

  Example:

  Shows how to determine the revision type of an inline node.

  Document doc = new Document(getMyDir() + "Revision runs.docx");
  
  // When we edit the document while the "Track Changes" option, found in via Review -> Tracking,
  // is turned on in Microsoft Word, the changes we apply count as revisions.
  // When editing a document using Aspose.Words, we can begin tracking revisions by
  // invoking the document's "StartTrackRevisions" method and stop tracking by using the "StopTrackRevisions" method.
  // We can either accept revisions to assimilate them into the document
  // or reject them to change the proposed change effectively.
  Assert.assertEquals(6, doc.getRevisions().getCount());
  
  // The parent node of a revision is the run that the revision concerns. A Run is an Inline node.
  Run run = (Run) doc.getRevisions().get(0).getParentNode();
  
  Paragraph firstParagraph = run.getParentParagraph();
  RunCollection runs = firstParagraph.getRuns();
  
  Assert.assertEquals(runs.getCount(), 6);
  
  // Below are five types of revisions that can flag an Inline node.
  // 1 -  An "insert" revision:
  // This revision occurs when we insert text while tracking changes.
  Assert.assertTrue(runs.get(2).isInsertRevision());
  
  // 2 -  A "format" revision:
  // This revision occurs when we change the formatting of text while tracking changes.
  Assert.assertTrue(runs.get(2).isFormatRevision());
  
  // 3 -  A "move from" revision:
  // When we highlight text in Microsoft Word, and then drag it to a different place in the document
  // while tracking changes, two revisions appear.
  // The "move from" revision is a copy of the text originally before we moved it.
  Assert.assertTrue(runs.get(4).isMoveFromRevision());
  
  // 4 -  A "move to" revision:
  // The "move to" revision is the text that we moved in its new position in the document.
  // "Move from" and "move to" revisions appear in pairs for every move revision we carry out.
  // Accepting a move revision deletes the "move from" revision and its text,
  // and keeps the text from the "move to" revision.
  // Rejecting a move revision conversely keeps the "move from" revision and deletes the "move to" revision.
  Assert.assertTrue(runs.get(1).isMoveToRevision());
  
  // 5 -  A "delete" revision:
  // This revision occurs when we delete text while tracking changes. When we delete text like this,
  // it will stay in the document as a revision until we either accept the revision,
  // which will delete the text for good, or reject the revision, which will keep the text we deleted where it was.
  Assert.assertTrue(runs.get(5).isDeleteRevision());

• isMoveFromRevision

  public boolean isMoveFromRevision()
  

  Returns true if this object was moved (deleted) in Microsoft Word while change tracking was enabled.

  Example:

  Shows how to determine the revision type of an inline node.

  Document doc = new Document(getMyDir() + "Revision runs.docx");
  
  // When we edit the document while the "Track Changes" option, found in via Review -> Tracking,
  // is turned on in Microsoft Word, the changes we apply count as revisions.
  // When editing a document using Aspose.Words, we can begin tracking revisions by
  // invoking the document's "StartTrackRevisions" method and stop tracking by using the "StopTrackRevisions" method.
  // We can either accept revisions to assimilate them into the document
  // or reject them to change the proposed change effectively.
  Assert.assertEquals(6, doc.getRevisions().getCount());
  
  // The parent node of a revision is the run that the revision concerns. A Run is an Inline node.
  Run run = (Run) doc.getRevisions().get(0).getParentNode();
  
  Paragraph firstParagraph = run.getParentParagraph();
  RunCollection runs = firstParagraph.getRuns();
  
  Assert.assertEquals(runs.getCount(), 6);
  
  // Below are five types of revisions that can flag an Inline node.
  // 1 -  An "insert" revision:
  // This revision occurs when we insert text while tracking changes.
  Assert.assertTrue(runs.get(2).isInsertRevision());
  
  // 2 -  A "format" revision:
  // This revision occurs when we change the formatting of text while tracking changes.
  Assert.assertTrue(runs.get(2).isFormatRevision());
  
  // 3 -  A "move from" revision:
  // When we highlight text in Microsoft Word, and then drag it to a different place in the document
  // while tracking changes, two revisions appear.
  // The "move from" revision is a copy of the text originally before we moved it.
  Assert.assertTrue(runs.get(4).isMoveFromRevision());
  
  // 4 -  A "move to" revision:
  // The "move to" revision is the text that we moved in its new position in the document.
  // "Move from" and "move to" revisions appear in pairs for every move revision we carry out.
  // Accepting a move revision deletes the "move from" revision and its text,
  // and keeps the text from the "move to" revision.
  // Rejecting a move revision conversely keeps the "move from" revision and deletes the "move to" revision.
  Assert.assertTrue(runs.get(1).isMoveToRevision());
  
  // 5 -  A "delete" revision:
  // This revision occurs when we delete text while tracking changes. When we delete text like this,
  // it will stay in the document as a revision until we either accept the revision,
  // which will delete the text for good, or reject the revision, which will keep the text we deleted where it was.
  Assert.assertTrue(runs.get(5).isDeleteRevision());

• isMoveToRevision

  public boolean isMoveToRevision()
  

  Returns true if this object was moved (inserted) in Microsoft Word while change tracking was enabled.

  Example:

  Shows how to determine the revision type of an inline node.

  Document doc = new Document(getMyDir() + "Revision runs.docx");
  
  // When we edit the document while the "Track Changes" option, found in via Review -> Tracking,
  // is turned on in Microsoft Word, the changes we apply count as revisions.
  // When editing a document using Aspose.Words, we can begin tracking revisions by
  // invoking the document's "StartTrackRevisions" method and stop tracking by using the "StopTrackRevisions" method.
  // We can either accept revisions to assimilate them into the document
  // or reject them to change the proposed change effectively.
  Assert.assertEquals(6, doc.getRevisions().getCount());
  
  // The parent node of a revision is the run that the revision concerns. A Run is an Inline node.
  Run run = (Run) doc.getRevisions().get(0).getParentNode();
  
  Paragraph firstParagraph = run.getParentParagraph();
  RunCollection runs = firstParagraph.getRuns();
  
  Assert.assertEquals(runs.getCount(), 6);
  
  // Below are five types of revisions that can flag an Inline node.
  // 1 -  An "insert" revision:
  // This revision occurs when we insert text while tracking changes.
  Assert.assertTrue(runs.get(2).isInsertRevision());
  
  // 2 -  A "format" revision:
  // This revision occurs when we change the formatting of text while tracking changes.
  Assert.assertTrue(runs.get(2).isFormatRevision());
  
  // 3 -  A "move from" revision:
  // When we highlight text in Microsoft Word, and then drag it to a different place in the document
  // while tracking changes, two revisions appear.
  // The "move from" revision is a copy of the text originally before we moved it.
  Assert.assertTrue(runs.get(4).isMoveFromRevision());
  
  // 4 -  A "move to" revision:
  // The "move to" revision is the text that we moved in its new position in the document.
  // "Move from" and "move to" revisions appear in pairs for every move revision we carry out.
  // Accepting a move revision deletes the "move from" revision and its text,
  // and keeps the text from the "move to" revision.
  // Rejecting a move revision conversely keeps the "move from" revision and deletes the "move to" revision.
  Assert.assertTrue(runs.get(1).isMoveToRevision());
  
  // 5 -  A "delete" revision:
  // This revision occurs when we delete text while tracking changes. When we delete text like this,
  // it will stay in the document as a revision until we either accept the revision,
  // which will delete the text for good, or reject the revision, which will keep the text we deleted where it was.
  Assert.assertTrue(runs.get(5).isDeleteRevision());

• getNextSibling

  public Node getNextSibling()
  

  Gets the node immediately following this node.

  If there is no next node, a null is returned.

  Example:

  Shows how to use a node's NextSibling property to enumerate through its immediate children.

  Document doc = new Document(getMyDir() + "Paragraphs.docx");
  
  for (Node node = doc.getFirstSection().getBody().getFirstChild(); node != null; node = node.getNextSibling()) {
      System.out.println(Node.nodeTypeToString(node.getNodeType()));
  }

  Example:

  Shows how to traverse a composite node's tree of child nodes.

  Document doc = new Document(getMyDir() + "Paragraphs.docx");
  
      // Any node that can contain child nodes, such as the document itself, is composite.
      Assert.assertTrue(doc.isComposite());
  
      // Invoke the recursive function that will go through and print all the child nodes of a composite node.
      traverseAllNodes(doc, 0);
  }
  
  /// <summary>
  /// Recursively traverses a node tree while printing the type of each node
  /// with an indent depending on depth as well as the contents of all inline nodes.
  /// </summary>
  @Test(enabled = false)
  public void traverseAllNodes(CompositeNode parentNode, int depth) {
      for (Node childNode = parentNode.getFirstChild(); childNode != null; childNode = childNode.getNextSibling()) {
          System.out.println(MessageFormat.format("{0}{1}", String.format("    ", depth), Node.nodeTypeToString(childNode.getNodeType())));
  
          // Recurse into the node if it is a composite node. Otherwise, print its contents if it is an inline node.
          if (childNode.isComposite()) {
              System.out.println();
              traverseAllNodes((CompositeNode) childNode, depth + 1);
          } else if (childNode instanceof Inline) {
              System.out.println(" - \"{childNode.GetText().Trim()}\"");
          } else {
              System.out.println();
          }
      }
  }

• getNodeType

  public int getNodeType()
  

  Returns NodeType.SpecialChar. The value of the property is NodeType integer constant.

  Example:

  Shows how to traverse a composite node's tree of child nodes.

  Document doc = new Document(getMyDir() + "Paragraphs.docx");
  
      // Any node that can contain child nodes, such as the document itself, is composite.
      Assert.assertTrue(doc.isComposite());
  
      // Invoke the recursive function that will go through and print all the child nodes of a composite node.
      traverseAllNodes(doc, 0);
  }
  
  /// <summary>
  /// Recursively traverses a node tree while printing the type of each node
  /// with an indent depending on depth as well as the contents of all inline nodes.
  /// </summary>
  @Test(enabled = false)
  public void traverseAllNodes(CompositeNode parentNode, int depth) {
      for (Node childNode = parentNode.getFirstChild(); childNode != null; childNode = childNode.getNextSibling()) {
          System.out.println(MessageFormat.format("{0}{1}", String.format("    ", depth), Node.nodeTypeToString(childNode.getNodeType())));
  
          // Recurse into the node if it is a composite node. Otherwise, print its contents if it is an inline node.
          if (childNode.isComposite()) {
              System.out.println();
              traverseAllNodes((CompositeNode) childNode, depth + 1);
          } else if (childNode instanceof Inline) {
              System.out.println(" - \"{childNode.GetText().Trim()}\"");
          } else {
              System.out.println();
          }
      }
  }

• getParentNode

  public CompositeNode getParentNode()
  

  Gets the immediate parent of this node.

  If a node has just been created and not yet added to the tree, or if it has been removed from the tree, the parent is null.

  Example:

  Shows how to access a node's parent node.

  Document doc = new Document();
  Paragraph para = doc.getFirstSection().getBody().getFirstParagraph();
  
  // Append a child Run node to the document's first paragraph.
  Run run = new Run(doc, "Hello world!");
  para.appendChild(run);
  
  // The paragraph is the parent node of the run node. We can trace this lineage
  // all the way to the document node, which is the root of the document's node tree.
  Assert.assertEquals(para, run.getParentNode());
  Assert.assertEquals(doc.getFirstSection().getBody(), para.getParentNode());
  Assert.assertEquals(doc.getFirstSection(), doc.getFirstSection().getBody().getParentNode());
  Assert.assertEquals(doc, doc.getFirstSection().getParentNode());

  Example:

  Shows how to create a node and set its owning document.

  Document doc = new Document();
  Paragraph para = new Paragraph(doc);
  para.appendChild(new Run(doc, "Hello world!"));
  
  // We have not yet appended this paragraph as a child to any composite node.
  Assert.assertNull(para.getParentNode());
  
  // If a node is an appropriate child node type of another composite node,
  // we can attach it as a child only if both nodes have the same owner document.
  // The owner document is the document we passed to the node's constructor.
  // We have not attached this paragraph to the document, so the document does not contain its text.
  Assert.assertEquals(para.getDocument(), doc);
  Assert.assertEquals("", doc.getText().trim());
  
  // Since the document owns this paragraph, we can apply one of its styles to the paragraph's contents.
  para.getParagraphFormat().setStyleName("Heading 1");
  
  // Add this node to the document, and then verify its contents.
  doc.getFirstSection().getBody().appendChild(para);
  
  Assert.assertEquals(doc.getFirstSection().getBody(), para.getParentNode());
  Assert.assertEquals("Hello world!", doc.getText().trim());

• getParentParagraph

  public Paragraph getParentParagraph()
  

  Retrieves the parent Paragraph of this node.

  Example:

  Shows how to determine the revision type of an inline node.

  Document doc = new Document(getMyDir() + "Revision runs.docx");
  
  // When we edit the document while the "Track Changes" option, found in via Review -> Tracking,
  // is turned on in Microsoft Word, the changes we apply count as revisions.
  // When editing a document using Aspose.Words, we can begin tracking revisions by
  // invoking the document's "StartTrackRevisions" method and stop tracking by using the "StopTrackRevisions" method.
  // We can either accept revisions to assimilate them into the document
  // or reject them to change the proposed change effectively.
  Assert.assertEquals(6, doc.getRevisions().getCount());
  
  // The parent node of a revision is the run that the revision concerns. A Run is an Inline node.
  Run run = (Run) doc.getRevisions().get(0).getParentNode();
  
  Paragraph firstParagraph = run.getParentParagraph();
  RunCollection runs = firstParagraph.getRuns();
  
  Assert.assertEquals(runs.getCount(), 6);
  
  // Below are five types of revisions that can flag an Inline node.
  // 1 -  An "insert" revision:
  // This revision occurs when we insert text while tracking changes.
  Assert.assertTrue(runs.get(2).isInsertRevision());
  
  // 2 -  A "format" revision:
  // This revision occurs when we change the formatting of text while tracking changes.
  Assert.assertTrue(runs.get(2).isFormatRevision());
  
  // 3 -  A "move from" revision:
  // When we highlight text in Microsoft Word, and then drag it to a different place in the document
  // while tracking changes, two revisions appear.
  // The "move from" revision is a copy of the text originally before we moved it.
  Assert.assertTrue(runs.get(4).isMoveFromRevision());
  
  // 4 -  A "move to" revision:
  // The "move to" revision is the text that we moved in its new position in the document.
  // "Move from" and "move to" revisions appear in pairs for every move revision we carry out.
  // Accepting a move revision deletes the "move from" revision and its text,
  // and keeps the text from the "move to" revision.
  // Rejecting a move revision conversely keeps the "move from" revision and deletes the "move to" revision.
  Assert.assertTrue(runs.get(1).isMoveToRevision());
  
  // 5 -  A "delete" revision:
  // This revision occurs when we delete text while tracking changes. When we delete text like this,
  // it will stay in the document as a revision until we either accept the revision,
  // which will delete the text for good, or reject the revision, which will keep the text we deleted where it was.
  Assert.assertTrue(runs.get(5).isDeleteRevision());

• getPreviousSibling

  public Node getPreviousSibling()
  

  Gets the node immediately preceding this node.

  If there is no preceding node, a null is returned.

  Example:

  Shows how to use of methods of Node and CompositeNode to remove a section before the last section in the document.

  Document doc = new Document();
  DocumentBuilder builder = new DocumentBuilder(doc);
  
  builder.writeln("Section 1 text.");
  builder.insertBreak(BreakType.SECTION_BREAK_CONTINUOUS);
  builder.writeln("Section 2 text.");
  
  // Both sections are siblings of each other.
  Section lastSection = (Section) doc.getLastChild();
  Section firstSection = (Section) lastSection.getPreviousSibling();
  
  // Remove a section based on its sibling relationship with another section.
  if (lastSection.getPreviousSibling() != null)
      doc.removeChild(firstSection);
  
  // The section we removed was the first one, leaving the document with only the second.
  Assert.assertEquals("Section 2 text.", doc.getText().trim());

• getRange

  public Range getRange()
  

  Returns a Range object that represents the portion of a document that is contained in this node.

  Example:

  Shows how to delete all the nodes from a range.

  Document doc = new Document();
  DocumentBuilder builder = new DocumentBuilder(doc);
  
  // Add text to the first section in the document, and then add another section.
  builder.write("Section 1. ");
  builder.insertBreak(BreakType.SECTION_BREAK_CONTINUOUS);
  builder.write("Section 2.");
  
  Assert.assertEquals("Section 1. \fSection 2.", doc.getText().trim());
  
  // Remove the first section entirely by removing all the nodes
  // within its range, including the section itself.
  doc.getSections().get(0).getRange().delete();
  
  Assert.assertEquals(1, doc.getSections().getCount());
  Assert.assertEquals("Section 2.", doc.getText().trim());

Method Detail

• accept

  public boolean accept(DocumentVisitor visitor)
                throws java.lang.Exception

  Accepts a visitor.

  Calls DocumentVisitor.VisitAbsolutePositionTab.

  For more info see the Visitor design pattern.

  Parameters:

  visitor - The visitor that will visit the node.

  Returns:

  False if the visitor requested the enumeration to stop.

  Example:

  Shows how to process absolute position tab characters with a document visitor.

  Document doc = new Document(getMyDir() + "Absolute position tab.docx");
  
      // Extract the text contents of our document by accepting this custom document visitor.
      DocTextExtractor myDocTextExtractor = new DocTextExtractor();
      doc.getFirstSection().getBody().accept(myDocTextExtractor);
  
      // The absolute position tab, which has no equivalent in string form, has been explicitly converted to a tab character.
      Assert.assertEquals("Before AbsolutePositionTab\tAfter AbsolutePositionTab", myDocTextExtractor.getText());
  
      // An AbsolutePositionTab can accept a DocumentVisitor by itself too.
      AbsolutePositionTab absPositionTab = (AbsolutePositionTab) doc.getFirstSection().getBody().getFirstParagraph().getChild(NodeType.SPECIAL_CHAR, 0, true);
  
      myDocTextExtractor = new DocTextExtractor();
      absPositionTab.accept(myDocTextExtractor);
  
      Assert.assertEquals("\t", myDocTextExtractor.getText());
  }
  
  /// <summary>
  /// Collects the text contents of all runs in the visited document. Replaces all absolute tab characters with ordinary tabs.
  /// </summary>
  public static class DocTextExtractor extends DocumentVisitor {
      public DocTextExtractor() {
          mBuilder = new StringBuilder();
      }
  
      /// <summary>
      /// Called when a Run node is encountered in the document.
      /// </summary>
      public int visitRun(final Run run) {
          appendText(run.getText());
          return VisitorAction.CONTINUE;
      }
  
      /// <summary>
      /// Called when an AbsolutePositionTab node is encountered in the document.
      /// </summary>
      public int visitAbsolutePositionTab(final AbsolutePositionTab tab) {
          mBuilder.append("\t");
  
          return VisitorAction.CONTINUE;
      }
  
      /// <summary>
      /// Adds text to the current output. Honors the enabled/disabled output flag.
      /// </summary>
      public void appendText(final String text) {
          mBuilder.append(text);
      }
  
      /// <summary>
      /// Plain text of the document that was accumulated by the visitor.
      /// </summary>
      public String getText() {
          return mBuilder.toString();
      }
  
      private final StringBuilder mBuilder;
  }

• deepClone

  public Node deepClone(boolean isCloneChildren)

  Creates a duplicate of the node.

  This method serves as a copy constructor for nodes. The cloned node has no parent, but belongs to the same document as the original node.

  This method always performs a deep copy of the node. The isCloneChildren parameter specifies whether to perform copy all child nodes as well.

  Parameters:

  isCloneChildren - True to recursively clone the subtree under the specified node; false to clone only the node itself.

  Returns:

  The cloned node.

  Example:

  Shows how to clone a composite node.

  Document doc = new Document();
  Paragraph para = doc.getFirstSection().getBody().getFirstParagraph();
  para.appendChild(new Run(doc, "Hello world!"));
  
  // Below are two ways of cloning a composite node.
  // 1 -  Create a clone of a node, and create a clone of each of its child nodes as well.
  Node cloneWithChildren = para.deepClone(true);
  
  Assert.assertTrue(((CompositeNode) cloneWithChildren).hasChildNodes());
  Assert.assertEquals("Hello world!", cloneWithChildren.getText().trim());
  
  // 2 -  Create a clone of a node just by itself without any children.
  Node cloneWithoutChildren = para.deepClone(false);
  
  Assert.assertFalse(((CompositeNode) cloneWithoutChildren).hasChildNodes());
  Assert.assertEquals("", cloneWithoutChildren.getText().trim());

• getAncestor

  public CompositeNode getAncestor(int ancestorType)

  Gets the first ancestor of the specified NodeType.

  Parameters:

  ancestorType - A NodeType value. The node type of the ancestor to retrieve.

  Returns:

  The ancestor of the specified type or null if no ancestor of this type was found.

  Example:

  Shows how to find out if a tables are nested.

  Document doc = new Document(getMyDir() + "Nested tables.docx");
      NodeCollection tables = doc.getChildNodes(NodeType.TABLE, true);
      for (int i = 0; i < tables.getCount(); i++) {
          Table table = (Table) tables.get(i);
  
          // Find out if any cells in the table have other tables as children.
          int count = getChildTableCount(table);
          System.out.print(MessageFormat.format("Table #{0} has {1} tables directly within its cells", i, count));
  
          // Find out if the table is nested inside another table, and, if so, at what depth.
          int tableDepth = getNestedDepthOfTable(table);
  
          if (tableDepth > 0)
              System.out.println(MessageFormat.format("Table #{0} is nested inside another table at depth of {1}", i, tableDepth));
          else
              System.out.println(MessageFormat.format("Table #{0} is a non nested table (is not a child of another table)", i));
      }
  }
  
  /**
   * Calculates what level a table is nested inside other tables.
   *
   * @returns An integer containing the level the table is nested at.
   * 0 = Table is not nested inside any other table
   * 1 = Table is nested within one parent table
   * 2 = Table is nested within two parent tables etc..
   */
  private static int getNestedDepthOfTable(final Table table) {
      int depth = 0;
      Node parent = table.getAncestor(table.getNodeType());
  
      while (parent != null) {
          depth++;
          parent = parent.getAncestor(Table.class);
      }
  
      return depth;
  }
  
  /**
   * Determines if a table contains any immediate child table within its cells.
   * Does not recursively traverse through those tables to check for further tables.
   *
   * @returns Returns true if at least one child cell contains a table.
   * Returns false if no cells in the table contains a table.
   */
  private static int getChildTableCount(final Table table) {
      int childTableCount = 0;
  
      for (Row row : table.getRows()) {
          for (Cell cell : row.getCells()) {
              TableCollection childTables = cell.getTables();
  
              if (childTables.getCount() > 0) childTableCount++;
          }
      }
  
      return childTableCount;
  }

• getAncestor

  public CompositeNode getAncestor(java.lang.Class ancestorType)

  Gets the first ancestor of the specified object type.

  The ancestor type matches if it is equal to ancestorType or derived from ancestorType.

  Parameters:

  ancestorType - The object type of the ancestor to retrieve.

  Returns:

  The ancestor of the specified type or null if no ancestor of this type was found.

  Example:

  Shows how to find out if a tables are nested.

  Document doc = new Document(getMyDir() + "Nested tables.docx");
      NodeCollection tables = doc.getChildNodes(NodeType.TABLE, true);
      for (int i = 0; i < tables.getCount(); i++) {
          Table table = (Table) tables.get(i);
  
          // Find out if any cells in the table have other tables as children.
          int count = getChildTableCount(table);
          System.out.print(MessageFormat.format("Table #{0} has {1} tables directly within its cells", i, count));
  
          // Find out if the table is nested inside another table, and, if so, at what depth.
          int tableDepth = getNestedDepthOfTable(table);
  
          if (tableDepth > 0)
              System.out.println(MessageFormat.format("Table #{0} is nested inside another table at depth of {1}", i, tableDepth));
          else
              System.out.println(MessageFormat.format("Table #{0} is a non nested table (is not a child of another table)", i));
      }
  }
  
  /**
   * Calculates what level a table is nested inside other tables.
   *
   * @returns An integer containing the level the table is nested at.
   * 0 = Table is not nested inside any other table
   * 1 = Table is nested within one parent table
   * 2 = Table is nested within two parent tables etc..
   */
  private static int getNestedDepthOfTable(final Table table) {
      int depth = 0;
      Node parent = table.getAncestor(table.getNodeType());
  
      while (parent != null) {
          depth++;
          parent = parent.getAncestor(Table.class);
      }
  
      return depth;
  }
  
  /**
   * Determines if a table contains any immediate child table within its cells.
   * Does not recursively traverse through those tables to check for further tables.
   *
   * @returns Returns true if at least one child cell contains a table.
   * Returns false if no cells in the table contains a table.
   */
  private static int getChildTableCount(final Table table) {
      int childTableCount = 0;
  
      for (Row row : table.getRows()) {
          for (Cell cell : row.getCells()) {
              TableCollection childTables = cell.getTables();
  
              if (childTables.getCount() > 0) childTableCount++;
          }
      }
  
      return childTableCount;
  }

• getText

  public java.lang.String getText()

  Gets the special character that this node represents.

  Returns:

  The string that contains the character that this node represents.

• nextPreOrder

  public Node nextPreOrder(Node rootNode)

  Gets next node according to the pre-order tree traversal algorithm.

  Parameters:

  rootNode - The top node (limit) of traversal.

  Returns:

  Next node in pre-order order. Null if reached the rootNode.

  Example:

  Shows how to traverse the document's node tree using the pre-order traversal algorithm, and delete any encountered shape with an image.

  Document doc = new Document(getMyDir() + "Images.docx");
  ArrayList<Shape> shapes = (ArrayList<Shape>) IterableUtils.toList(doc.getChildNodes(NodeType.SHAPE, true));
  
  Assert.assertEquals(9, IterableUtils.countMatches(shapes, s -> {
      try {
          return s.hasImage();
      } catch (Exception e) {
          e.printStackTrace();
      }
      return false;
  }));
  
  Node curNode = doc;
  while (curNode != null) {
      Node nextNode = curNode.nextPreOrder(doc);
  
      if (curNode.previousPreOrder(doc) != null && nextNode != null)
          Assert.assertEquals(curNode, nextNode.previousPreOrder(doc));
  
      if (curNode.getNodeType() == NodeType.SHAPE && ((Shape) curNode).hasImage())
          curNode.remove();
  
      curNode = nextNode;
  }
  
  shapes = (ArrayList<Shape>) IterableUtils.toList(doc.getChildNodes(NodeType.SHAPE, true));
  
  Assert.assertEquals(0, IterableUtils.countMatches(shapes, s -> {
      try {
          return s.hasImage();
      } catch (Exception e) {
          e.printStackTrace();
      }
      return false;
  }));

• previousPreOrder

  public Node previousPreOrder(Node rootNode)

  Gets the previous node according to the pre-order tree traversal algorithm.

  Parameters:

  rootNode - The top node (limit) of traversal.

  Returns:

  Previous node in pre-order order. Null if reached the rootNode.

  Example:

  Shows how to traverse the document's node tree using the pre-order traversal algorithm, and delete any encountered shape with an image.

  Document doc = new Document(getMyDir() + "Images.docx");
  ArrayList<Shape> shapes = (ArrayList<Shape>) IterableUtils.toList(doc.getChildNodes(NodeType.SHAPE, true));
  
  Assert.assertEquals(9, IterableUtils.countMatches(shapes, s -> {
      try {
          return s.hasImage();
      } catch (Exception e) {
          e.printStackTrace();
      }
      return false;
  }));
  
  Node curNode = doc;
  while (curNode != null) {
      Node nextNode = curNode.nextPreOrder(doc);
  
      if (curNode.previousPreOrder(doc) != null && nextNode != null)
          Assert.assertEquals(curNode, nextNode.previousPreOrder(doc));
  
      if (curNode.getNodeType() == NodeType.SHAPE && ((Shape) curNode).hasImage())
          curNode.remove();
  
      curNode = nextNode;
  }
  
  shapes = (ArrayList<Shape>) IterableUtils.toList(doc.getChildNodes(NodeType.SHAPE, true));
  
  Assert.assertEquals(0, IterableUtils.countMatches(shapes, s -> {
      try {
          return s.hasImage();
      } catch (Exception e) {
          e.printStackTrace();
      }
      return false;
  }));

• remove

  public void remove()

  Removes itself from the parent.

  Example:

  Shows how to delete all shapes with images from a document.

  Document doc = new Document(getMyDir() + "Images.docx");
  ArrayList<Shape> shapes = (ArrayList<Shape>) IterableUtils.toList(doc.getChildNodes(NodeType.SHAPE, true));
  
  Assert.assertEquals(9, IterableUtils.countMatches(shapes, s -> {
      try {
          return s.hasImage();
      } catch (Exception e) {
          e.printStackTrace();
      }
      return false;
  }));
  
  for (Shape shape : shapes)
      if (shape.hasImage())
          shape.remove();
  
  shapes = (ArrayList<Shape>) IterableUtils.toList(doc.getChildNodes(NodeType.SHAPE, true));
  
  Assert.assertEquals(0, IterableUtils.countMatches(shapes, s -> {
      try {
          return s.hasImage();
      } catch (Exception e) {
          e.printStackTrace();
      }
      return false;
  }));

  Example:

  Shows how to remove all child nodes of a specific type from a composite node.

  Document doc = new Document(getMyDir() + "Tables.docx");
  
  Assert.assertEquals(2, doc.getChildNodes(NodeType.TABLE, true).getCount());
  
  Node curNode = doc.getFirstSection().getBody().getFirstChild();
  
  while (curNode != null) {
      // Save the next sibling node as a variable in case we want to move to it after deleting this node.
      Node nextNode = curNode.getNextSibling();
  
      // A section body can contain Paragraph and Table nodes.
      // If the node is a Table, remove it from the parent.
      if (curNode.getNodeType() == NodeType.TABLE) {
          curNode.remove();
      }
  
      curNode = nextNode;
  }
  
  Assert.assertEquals(0, doc.getChildNodes(NodeType.TABLE, true).getCount());

• toString

  public java.lang.String toString(SaveOptions saveOptions)
                 throws java.lang.Exception

  Exports the content of the node into a string using the specified save options.

  Parameters:

  saveOptions - Specifies the options that control how the node is saved.

  Returns:

  The content of the node in the specified format.

  Example:

  Exports the content of a node to String in HTML format.

  Document doc = new Document(getMyDir() + "Document.docx");
  
  Node node = doc.getLastSection().getBody().getLastParagraph();
  
  // When we call the ToString method using the html SaveFormat overload,
  // it converts the node's contents to their raw html representation.
  Assert.assertEquals("<p style=\"margin-top:0pt; margin-bottom:8pt; line-height:108%; font-size:12pt\">" +
          "<span style=\"font-family:'Times New Roman'\">Hello World!</span>" +
          "</p>", node.toString(SaveFormat.HTML));
  
  // We can also modify the result of this conversion using a SaveOptions object.
  HtmlSaveOptions saveOptions = new HtmlSaveOptions();
  saveOptions.setExportRelativeFontSize(true);
  
  Assert.assertEquals("<p style=\"margin-top:0pt; margin-bottom:8pt; line-height:108%\">" +
          "<span style=\"font-family:'Times New Roman'\">Hello World!</span>" +
          "</p>", node.toString(saveOptions));

• toString

  public java.lang.String toString(int saveFormat)
                 throws java.lang.Exception

  Exports the content of the node into a string in the specified format.

  Returns:

  The content of the node in the specified format.

  Parameters:

  saveFormat - A SaveFormat value.

  Example:

  Shows how to extract the list labels of all paragraphs that are list items.

  Document doc = new Document(getMyDir() + "Rendering.docx");
  doc.updateListLabels();
  int listParaCount = 1;
  
  for (Paragraph paragraph : (Iterable<Paragraph>) doc.getChildNodes(NodeType.PARAGRAPH, true)) {
      // Find if we have the paragraph list. In our document, our list uses plain Arabic numbers,
      // which start at three and ends at six.
      if (paragraph.getListFormat().isListItem()) {
          System.out.println(MessageFormat.format("List item paragraph #{0}", listParaCount));
  
          // This is the text we get when getting when we output this node to text format.
          // This text output will omit list labels. Trim any paragraph formatting characters. 
          String paragraphText = paragraph.toString(SaveFormat.TEXT).trim();
          System.out.println("Exported Text: " + paragraphText);
  
          ListLabel label = paragraph.getListLabel();
  
          // This gets the position of the paragraph in the current level of the list. If we have a list with multiple levels,
          // this will tell us what position it is on that level.
          System.out.println("\tNumerical Id: {label.LabelValue}");
  
          // Combine them together to include the list label with the text in the output.
          System.out.println("\tList label combined with text: {label.LabelString} {paragraphText}");
      }

  Example:

  Exports the content of a node to String in HTML format.

  Document doc = new Document(getMyDir() + "Document.docx");
  
  Node node = doc.getLastSection().getBody().getLastParagraph();
  
  // When we call the ToString method using the html SaveFormat overload,
  // it converts the node's contents to their raw html representation.
  Assert.assertEquals("<p style=\"margin-top:0pt; margin-bottom:8pt; line-height:108%; font-size:12pt\">" +
          "<span style=\"font-family:'Times New Roman'\">Hello World!</span>" +
          "</p>", node.toString(SaveFormat.HTML));
  
  // We can also modify the result of this conversion using a SaveOptions object.
  HtmlSaveOptions saveOptions = new HtmlSaveOptions();
  saveOptions.setExportRelativeFontSize(true);
  
  Assert.assertEquals("<p style=\"margin-top:0pt; margin-bottom:8pt; line-height:108%\">" +
          "<span style=\"font-family:'Times New Roman'\">Hello World!</span>" +
          "</p>", node.toString(saveOptions));

  Example:

  Shows the difference between calling the GetText and ToString methods on a node.

  Document doc = new Document();
  
  DocumentBuilder builder = new DocumentBuilder(doc);
  builder.insertField("MERGEFIELD Field");
  
  // GetText will retrieve the visible text as well as field codes and special characters.
  Assert.assertEquals("\u0013MERGEFIELD Field\u0014«Field»\u0015\f", doc.getText());
  
  // ToString will give us the document's appearance if saved to a passed save format.
  Assert.assertEquals("«Field»\r\n", doc.toString(SaveFormat.TEXT));