java.lang.Objectcom.aspose.words.NodeList
public class NodeList
NodeList is returned by NodeList supports indexed access and iteration. Example:Note: Treat the NodeList collection as a "snapshot" collection. NodeList starts
as a "live" collection because the nodes are not actually retrieved when the XPath query is run.
The nodes are only retrieved upon access and at this time the node and all nodes that precede
it are cached forming a "snapshot" collection.
import com.aspose.words.*;
import java.lang.Exception;
import java.text.MessageFormat;
import java.util.regex.Pattern;
import java.util.regex.Matcher;
/// <summary>
/// Shows how to replace hyperlinks in a Word document.
/// </summary>
public class ExReplaceHyperlinks extends ExBase
{
/// <summary>
/// Finds all hyperlinks in a Word document and changes their URL and display name.
/// </summary>
public void ReplaceHyperlinks() throws Exception
{
// Specify your document name here.
Document doc = new Document(getMyDir() + "ReplaceHyperlinks.doc");
// Hyperlinks in a Word documents are fields, select all field start nodes so we can find the hyperlinks.
NodeList fieldStarts = doc.selectNodes("//FieldStart");
for (Node fieldStartNode : fieldStarts)
{
FieldStart fieldStart = (FieldStart) fieldStartNode;
if (fieldStart.getFieldType() == FieldType.FIELD_HYPERLINK)
{
// The field is a hyperlink field, use the "facade" class to help to deal with the field.
Hyperlink hyperlink = new Hyperlink(fieldStart);
// Some hyperlinks can be local (links to bookmarks inside the document), ignore these.
if (hyperlink.isLocal())
continue;
// The Hyperlink class allows to set the target URL and the display name
// of the link easily by setting the properties.
hyperlink.setTarget(NewUrl);
hyperlink.setName(NewName);
}
}
doc.save(getMyDir() + "ReplaceHyperlinks Out.doc");
}
private final String NewUrl = "http://www.aspose.com";
private final String NewName = "Aspose - The .NET & Java Component Publisher";
}
/// <summary>
/// This "facade" class makes it easier to work with a hyperlink field in a Word document.
///
/// A hyperlink is represented by a HYPERLINK field in a Word document. A field in Aspose.Words
/// consists of several nodes and it might be difficult to work with all those nodes directly.
/// Note this is a simple implementation and will work only if the hyperlink code and name
/// each consist of one Run only.
///
/// [FieldStart][Run - field code][FieldSeparator][Run - field result][FieldEnd]
///
/// The field code contains a string in one of these formats:
/// HYPERLINK "url"
/// HYPERLINK \l "bookmark name"
///
/// The field result contains text that is displayed to the user.
/// </summary>
class Hyperlink
{
Hyperlink(FieldStart fieldStart) throws Exception
{
if (fieldStart == null)
throw new Exception("Argument 'fieldStart' is null");
if (fieldStart.getFieldType() != FieldType.FIELD_HYPERLINK)
throw new Exception("Field start type must be FieldHyperlink.");
mFieldStart = fieldStart;
// Find the field separator node.
mFieldSeparator = FindNextSibling(mFieldStart, NodeType.FIELD_SEPARATOR);
if (mFieldSeparator == null)
throw new Exception("Cannot find field separator.");
// Find the field end node. Normally field end will always be found, but in the example document
// there happens to be a paragraph break included in the hyperlink and this puts the field end
// in the next paragraph. It will be much more complicated to handle fields which span several
// paragraphs correctly, but in this case allowing field end to be null is enough for our purposes.
mFieldEnd = FindNextSibling(mFieldSeparator, NodeType.FIELD_END);
// Field code looks something like [ HYPERLINK "http:\\www.myurl.com" ], but it can consist of several runs.
String fieldCode = GetTextSameParent(mFieldStart.getNextSibling(), mFieldSeparator);
Matcher match = gRegex.matcher(fieldCode.trim());
if (match.matches())
{
mIsLocal = match.group(1) != null; //The link is local if \l is present in the field code.
mTarget = match.group(2);
}
}
/// <summary>
/// Gets or sets the display name of the hyperlink.
/// </summary>
public String getName() throws Exception
{
return GetTextSameParent(mFieldSeparator, mFieldEnd);
}
public void setName(String value) throws Exception
{
// Hyperlink display name is stored in the field result which is a Run
// node between field separator and field end.
Run fieldResult = (Run)mFieldSeparator.getNextSibling();
fieldResult.setText(value);
// But sometimes the field result can consist of more than one run, delete these runs.
RemoveSameParent(fieldResult.getNextSibling(), mFieldEnd);
}
/// <summary>
/// Gets or sets the target url or bookmark name of the hyperlink.
/// </summary>
public String getTarget()
{
return mTarget;
}
public String setTarget(String value) throws Exception
{
mTarget = value;
UpdateFieldCode();
return mTarget;
}
/// <summary>
/// True if the hyperlink's target is a bookmark inside the document. False if the hyperlink is a url.
/// </summary>
public boolean isLocal()
{
return mIsLocal;
}
public void isLocal(boolean value) throws Exception
{
mIsLocal = value;
UpdateFieldCode();
}
private void UpdateFieldCode() throws Exception
{
// Field code is stored in a Run node between field start and field separator.
Run fieldCode = (Run)mFieldStart.getNextSibling();
fieldCode.setText(MessageFormat.format("HYPERLINK {0}\"{1}\"", ((mIsLocal) ? "\\l " : ""), mTarget));
// But sometimes the field code can consist of more than one run, delete these runs.
RemoveSameParent(fieldCode.getNextSibling(), mFieldSeparator);
}
/// <summary>
/// Goes through siblings starting from the start node until it finds a node of the specified type or null.
/// </summary>
private static Node FindNextSibling(Node startNode, int nodeType)
{
for (Node node = startNode; node != null; node = node.getNextSibling())
{
if (node.getNodeType() == nodeType)
return node;
}
return null;
}
/// <summary>
/// Retrieves text from start up to but not including the end node.
/// </summary>
private static String GetTextSameParent(Node startNode, Node endNode) throws Exception
{
if ((endNode != null) && (startNode.getParentNode() != endNode.getParentNode()))
throw new Exception("Start and end nodes are expected to have the same parent.");
StringBuilder builder = new StringBuilder();
for (Node child = startNode; child != endNode; child = child.getNextSibling())
builder.append(child.getText());
return builder.toString();
}
/// <summary>
/// Removes nodes from start up to but not including the end node.
/// Start and end are assumed to have the same parent.
/// </summary>
private static void RemoveSameParent(Node startNode, Node endNode) throws Exception
{
if ((endNode != null) && (startNode.getParentNode() != endNode.getParentNode()))
throw new Exception("Start and end nodes are expected to have the same parent.");
Node curChild = startNode;
while ((curChild != null) && (curChild != endNode))
{
Node nextChild = curChild.getNextSibling();
curChild.remove();
curChild = nextChild;
}
}
private final Node mFieldStart;
private final Node mFieldSeparator;
private final Node mFieldEnd;
private String mTarget;
private boolean mIsLocal;
/// <summary>
/// RK I am notoriously bad at regexes. It seems I don't understand their way of thinking.
/// </summary>
private static Pattern gRegex = Pattern.compile(
"\\S+" + // one or more non spaces HYPERLINK or other word in other languages
"\\s+" + // one or more spaces
"(?:\"\"\\s+)?" + // non capturing optional "" and one or more spaces, found in one of the customers files.
"(\\\\l\\s+)?" + // optional \l flag followed by one or more spaces
"\"" + // one apostrophe
"([^\"]+)" + // one or more chars except apostrophe (hyperlink target)
"\"" // one closing apostrophe
);
}
Property Getters/Setters Summary | ||
---|---|---|
int | getCount() | |
Gets the number of nodes in the list. | ||
Node | get(int index) | |
Retrieves a node at the given index. |
Method Summary | ||
---|---|---|
java.util.Iterator | iterator() | |
Provides a simple "foreach" style iteration over the collection of nodes. | ||
Aspose.Words.Node[] | toArray() | |
Copies all nodes from the collection to a new array of nodes. |
Property Getters/Setters Detail |
---|
getCount | |
public int getCount() |
get | |
public Node get(int index) |
The index is zero-based.
Negative indexes are allowed and indicate access from the back of the collection. For example -1 means the last item, -2 means the second before last and so on.
If index is greater than or equal to the number of items in the list, this returns a null reference.
If index is negative and its absolute value is greater than the number of items in the list, this returns a null reference.
index
- An index into the list of nodes.Method Detail |
---|
toArray | |
public Aspose.Words.Node[] toArray() |
You should not be adding/removing nodes while iterating over a collection of nodes because it invalidates the iterator and requires refreshes for live collections.
To be able to add/remove nodes during iteration, use this method to copy nodes into a fixed-size array and then iterate over the array.
iterator | |
public java.util.Iterator iterator() |