/// <summary>
/// Tweak old XMP: Move an instance ID from rdf:about to the
/// <em>xmpMM:InstanceID</em> property.
/// </summary>
/// <remarks>
/// Tweak old XMP: Move an instance ID from rdf:about to the
/// <em>xmpMM:InstanceID</em> property. An old instance ID usually looks
/// like "uuid:bac965c4-9d87-11d9-9a30-000d936b79c4", plus InDesign
/// 3.0 wrote them like "bac965c4-9d87-11d9-9a30-000d936b79c4". If
/// the name looks like a UUID simply move it to <em>xmpMM:InstanceID</em>,
/// don't worry about any existing <em>xmpMM:InstanceID</em>. Both will
/// only be present when a newer file with the <em>xmpMM:InstanceID</em>
/// property is updated by an old app that uses <em>rdf:about</em>.
/// </remarks>
/// <param name="tree">the root of the metadata tree</param>
/// <exception cref="iText.Kernel.XMP.XMPException">Thrown if tweaking fails.</exception>
private static void TweakOldXMP(XMPNode tree)
{
if (tree.GetName() != null && tree.GetName().Length >= Utils.UUID_LENGTH)
{
String nameStr = tree.GetName().ToLower();
if (nameStr.StartsWith("uuid:"))
{
nameStr = nameStr.Substring(5);
}
if (Utils.CheckUUIDFormat(nameStr))
{
// move UUID to xmpMM:InstanceID and remove it from the root node
XMPPath path = XMPPathParser.ExpandXPath(XMPConst.NS_XMP_MM, "InstanceID");
XMPNode idNode = XMPNodeUtils.FindNode(tree, path, true, null);
if (idNode != null)
{
idNode.SetOptions(null);
// Clobber any existing xmpMM:InstanceID.
idNode.SetValue("uuid:" + nameStr);
idNode.RemoveChildren();
idNode.RemoveQualifiers();
tree.SetName(null);
}
else
{
throw new XMPException("Failure creating xmpMM:InstanceID", XMPError.INTERNALFAILURE
);
}
}
}
}
/// <summary>Visit all schemas to do general fixes and handle special cases.</summary>
/// <param name="xmp">the metadata object implementation</param>
/// <exception cref="iText.Kernel.XMP.XMPException">Thrown if the normalisation fails.
/// </exception>
private static void TouchUpDataModel(XMPMetaImpl xmp)
{
// make sure the DC schema is existing, because it might be needed within the normalization
// if not touched it will be removed by removeEmptySchemas
XMPNodeUtils.FindSchemaNode(xmp.GetRoot(), XMPConst.NS_DC, true);
// Do the special case fixes within each schema.
for (IEnumerator it = xmp.GetRoot().IterateChildren(); it.MoveNext();)
{
XMPNode currSchema = (XMPNode)it.Current;
if (XMPConst.NS_DC.Equals(currSchema.GetName()))
{
NormalizeDCArrays(currSchema);
}
else
{
if (XMPConst.NS_EXIF.Equals(currSchema.GetName()))
{
// Do a special case fix for exif:GPSTimeStamp.
FixGPSTimeStamp(currSchema);
XMPNode arrayNode = XMPNodeUtils.FindChildNode(currSchema, "exif:UserComment", false
);
if (arrayNode != null)
{
RepairAltText(arrayNode);
}
}
else
{
if (XMPConst.NS_DM.Equals(currSchema.GetName()))
{
// Do a special case migration of xmpDM:copyright to
// dc:rights['x-default'].
XMPNode dmCopyright = XMPNodeUtils.FindChildNode(currSchema, "xmpDM:copyright", false
);
if (dmCopyright != null)
{
MigrateAudioCopyright(xmp, dmCopyright);
}
}
else
{
if (XMPConst.NS_XMP_RIGHTS.Equals(currSchema.GetName()))
{
XMPNode arrayNode = XMPNodeUtils.FindChildNode(currSchema, "xmpRights:UsageTerms"
, false);
if (arrayNode != null)
{
RepairAltText(arrayNode);
}
}
}
}
}
}
}
/// <summary>
/// Searches for a field selector in a node:
/// [fieldName="value] - an element in an array of structs, chosen by a field value.
/// </summary>
/// <remarks>
/// Searches for a field selector in a node:
/// [fieldName="value] - an element in an array of structs, chosen by a field value.
/// No implicit nodes are created by field selectors.
/// </remarks>
/// <param name="arrayNode"/>
/// <param name="fieldName"/>
/// <param name="fieldValue"/>
/// <returns>Returns the index of the field if found, otherwise -1.</returns>
/// <exception cref="iText.Kernel.XMP.XMPException"></exception>
private static int LookupFieldSelector(XMPNode arrayNode, String fieldName, String
fieldValue)
{
int result = -1;
for (int index = 1; index <= arrayNode.GetChildrenLength() && result < 0; index++)
{
XMPNode currItem = arrayNode.GetChild(index);
if (!currItem.GetOptions().IsStruct())
{
throw new XMPException("Field selector must be used on array of struct", XMPError
.BADXPATH);
}
for (int f = 1; f <= currItem.GetChildrenLength(); f++)
{
XMPNode currField = currItem.GetChild(f);
if (!fieldName.Equals(currField.GetName()))
{
continue;
}
if (fieldValue.Equals(currField.GetValue()))
{
result = index;
break;
}
}
}
return(result);
}
/// <summary>The outermost call is special.</summary>
/// <remarks>
/// The outermost call is special. The names almost certainly differ. The
/// qualifiers (and hence options) will differ for an alias to the x-default
/// item of a langAlt array.
/// </remarks>
/// <param name="aliasNode">the alias node</param>
/// <param name="baseNode">the base node of the alias</param>
/// <param name="outerCall">marks the outer call of the recursion</param>
/// <exception cref="iText.Kernel.XMP.XMPException">Forwards XMP errors</exception>
private static void CompareAliasedSubtrees(XMPNode aliasNode, XMPNode baseNode, bool
outerCall)
{
if (!aliasNode.GetValue().Equals(baseNode.GetValue()) ||
aliasNode.GetChildrenLength() != baseNode.GetChildrenLength())
{
throw new XMPException("Mismatch between alias and base nodes", XMPError.BADXMP);
}
if (!outerCall &&
(!aliasNode.GetName().Equals(baseNode.GetName()) || !aliasNode.GetOptions().Equals(baseNode.GetOptions()) ||
aliasNode.GetQualifierLength() != baseNode.GetQualifierLength()))
{
throw new XMPException("Mismatch between alias and base nodes", XMPError.BADXMP);
}
for (IEnumerator an = aliasNode.IterateChildren(), bn = baseNode.IterateChildren();
an.MoveNext() && bn.MoveNext();)
{
XMPNode aliasChild = (XMPNode)an.Current;
XMPNode baseChild = (XMPNode)bn.Current;
CompareAliasedSubtrees(aliasChild, baseChild, false);
}
for (IEnumerator an = aliasNode.IterateQualifier(), bn = baseNode.IterateQualifier();
an.MoveNext() && bn.MoveNext();)
{
XMPNode aliasQual = (XMPNode)an.Current;
XMPNode baseQual = (XMPNode)bn.Current;
CompareAliasedSubtrees(aliasQual, baseQual, false);
}
}
/// <summary>
/// Prepares the next node to return if not already done.
/// </summary>
/// <seealso cref="IEnumerator.MoveNext"/>
public override bool MoveNext()
{
if (outerInstance.skipSiblings)
{
return(false);
}
if (childrenIterator.MoveNext())
{
XMPNode child = (XMPNode)childrenIterator.Current;
if (child != null)
{
index++;
string path = null;
if (child.GetOptions().IsSchemaNode())
{
outerInstance.SetBaseNS(child.GetName());
}
else if (child.GetParent() != null)
{
// for all but the root node and schema nodes
path = AccumulatePath(child, parentPath, index);
}
// report next property, skip not-leaf nodes in case options is set
if (!outerInstance.GetOptions().IsJustLeafnodes() || !child.HasChildren())
{
SetReturnProperty(CreatePropertyInfo(child, outerInstance.GetBaseNS(), path));
return(true);
}
}
return(MoveNext());
}
return(false);
}
/// <param name="currNode"> the node that will be added to the path. </param>
/// <param name="parentPath"> the path up to this node. </param>
/// <param name="currentIndex"> the current array index if an arrey is traversed </param>
/// <returns> Returns the updated path. </returns>
protected internal virtual String AccumulatePath(XMPNode currNode, string parentPath, int currentIndex)
{
String separator;
String segmentName;
if (currNode.GetParent() == null || currNode.GetOptions().IsSchemaNode())
{
return(null);
}
if (currNode.GetParent().GetOptions().IsArray())
{
separator = "";
segmentName = "[" + Convert.ToString(currentIndex) + "]";
}
else
{
separator = "/";
segmentName = currNode.GetName();
}
if (String.IsNullOrEmpty(parentPath))
{
return(segmentName);
}
if (outerInstance.GetOptions().IsJustLeafname())
{
return(!segmentName.StartsWith("?") ? segmentName : segmentName.Substring(1)); // qualifier
}
return(parentPath + separator + segmentName);
}
public virtual string GetNamespace()
{
if (!node.GetOptions().IsSchemaNode())
{
// determine namespace of leaf node
QName qname = new QName(node.GetName());
return(XMPMetaFactory.GetSchemaRegistry().GetNamespaceURI(qname.GetPrefix()));
}
return(baseNs);
}
/// <summary>
/// Undo the denormalization performed by the XMP used in Acrobat 5.<br />
/// If a Dublin Core array had only one item, it was serialized as a simple
/// property.
/// </summary>
/// <remarks>
/// Undo the denormalization performed by the XMP used in Acrobat 5.<br />
/// If a Dublin Core array had only one item, it was serialized as a simple
/// property. <br />
/// The <code>xml:lang</code> attribute was dropped from an
/// <code>alt-text</code> item if the language was <code>x-default</code>.
/// </remarks>
/// <param name="dcSchema">the DC schema node</param>
/// <exception cref="iText.Kernel.XMP.XMPException">Thrown if normalization fails
/// </exception>
private static void NormalizeDCArrays(XMPNode dcSchema)
{
for (int i = 1; i <= dcSchema.GetChildrenLength(); i++)
{
XMPNode currProp = dcSchema.GetChild(i);
PropertyOptions arrayForm = (PropertyOptions)dcArrayForms[currProp.GetName()];
if (arrayForm == null)
{
continue;
}
else
{
if (currProp.GetOptions().IsSimple())
{
// create a new array and add the current property as child,
// if it was formerly simple
XMPNode newArray = new XMPNode(currProp.GetName(), arrayForm);
currProp.SetName(XMPConst.ARRAY_ITEM_NAME);
newArray.AddChild(currProp);
dcSchema.ReplaceChild(i, newArray);
// fix language alternatives
if (arrayForm.IsArrayAltText() && !currProp.GetOptions().GetHasLanguage())
{
XMPNode newLang = new XMPNode(XMPConst.XML_LANG, XMPConst.X_DEFAULT, null);
currProp.AddQualifier(newLang);
}
}
else
{
// clear array options and add corrected array form if it has been an array before
currProp.GetOptions().SetOption(PropertyOptions.ARRAY | PropertyOptions.ARRAY_ORDERED
| PropertyOptions.ARRAY_ALTERNATE | PropertyOptions.ARRAY_ALT_TEXT, false);
currProp.GetOptions().MergeWith(arrayForm);
if (arrayForm.IsArrayAltText())
{
// applying for "dc:description", "dc:rights", "dc:title"
RepairAltText(currProp);
}
}
}
}
}
/// <summary>
/// Constructor </summary>
/// <param name="parentNode"> the node which children shall be iterated. </param>
/// <param name="parentPath"> the full path of the former node without the leaf node. </param>
public NodeIteratorChildren(XMPIteratorImpl outerInstance, XMPNode parentNode, string parentPath)
: base(outerInstance, parentNode, parentPath, 0)
{
this.outerInstance = outerInstance;
if (parentNode.GetOptions().IsSchemaNode())
{
outerInstance.SetBaseNS(parentNode.GetName());
}
this.parentPath = AccumulatePath(parentNode, parentPath, 1);
this.childrenIterator = parentNode.IterateChildren();
}
/// <summary>This is setting the value of a leaf node.</summary>
/// <param name="node">an XMPNode</param>
/// <param name="value">a value</param>
internal static void SetNodeValue(XMPNode node, Object value)
{
String strValue = SerializeNodeValue(value);
if (!(node.GetOptions().IsQualifier() && XML_LANG.Equals(node.GetName())))
{
node.SetValue(strValue);
}
else
{
node.SetValue(iText.Kernel.XMP.Impl.Utils.NormalizeLangValue(strValue));
}
}
/// <summary>
/// Constructor for the node iterator. </summary>
/// <param name="visitedNode"> the currently visited node </param>
/// <param name="parentPath"> the accumulated path of the node </param>
/// <param name="index"> the index within the parent node (only for arrays) </param>
public NodeIterator(XMPIteratorImpl outerInstance, XMPNode visitedNode, string parentPath, int index)
{
this.outerInstance = outerInstance;
this.visitedNode = visitedNode;
this.state = ITERATE_NODE;
if (visitedNode.GetOptions().IsSchemaNode())
{
outerInstance.SetBaseNS(visitedNode.GetName());
}
// for all but the root node and schema nodes
this.path = AccumulatePath(visitedNode, parentPath, index);
}
/// <summary>
/// Searches for a qualifier selector in a node:
/// [?qualName="value"] - an element in an array, chosen by a qualifier value.
/// </summary>
/// <remarks>
/// Searches for a qualifier selector in a node:
/// [?qualName="value"] - an element in an array, chosen by a qualifier value.
/// No implicit nodes are created for qualifier selectors,
/// except for an alias to an x-default item.
/// </remarks>
/// <param name="arrayNode">an array node</param>
/// <param name="qualName">the qualifier name</param>
/// <param name="qualValue">the qualifier value</param>
/// <param name="aliasForm">
/// in case the qual selector results from an alias,
/// an x-default node is created if there has not been one.
/// </param>
/// <returns>Returns the index of th</returns>
/// <exception cref="iText.Kernel.XMP.XMPException"></exception>
private static int LookupQualSelector(XMPNode arrayNode, String qualName, String
qualValue, int aliasForm)
{
if (XML_LANG.Equals(qualName))
{
qualValue = iText.Kernel.XMP.Impl.Utils.NormalizeLangValue(qualValue);
int index = XMPNodeUtils.LookupLanguageItem(arrayNode, qualValue);
if (index < 0 && (aliasForm & AliasOptions.PROP_ARRAY_ALT_TEXT) > 0)
{
XMPNode langNode = new XMPNode(ARRAY_ITEM_NAME, null);
XMPNode xdefault = new XMPNode(XML_LANG, X_DEFAULT, null);
langNode.AddQualifier(xdefault);
arrayNode.AddChild(1, langNode);
return(1);
}
else
{
return(index);
}
}
else
{
for (int index = 1; index < arrayNode.GetChildrenLength(); index++)
{
XMPNode currItem = arrayNode.GetChild(index);
for (IEnumerator it = currItem.IterateQualifier(); it.MoveNext();)
{
XMPNode qualifier = (XMPNode)it.Current;
if (qualName.Equals(qualifier.GetName()) && qualValue.Equals(qualifier.GetValue()
))
{
return(index);
}
}
}
return(-1);
}
}
/// <summary>Visit all of the top level nodes looking for aliases.</summary>
/// <remarks>
/// Visit all of the top level nodes looking for aliases. If there is
/// no base, transplant the alias subtree. If there is a base and strict
/// aliasing is on, make sure the alias and base subtrees match.
/// </remarks>
/// <param name="tree">the root of the metadata tree</param>
/// <param name="options">th parsing options</param>
/// <exception cref="iText.Kernel.XMP.XMPException">Forwards XMP errors</exception>
private static void MoveExplicitAliases(XMPNode tree, ParseOptions options)
{
if (!tree.GetHasAliases())
{
return;
}
tree.SetHasAliases(false);
bool strictAliasing = options.GetStrictAliasing();
IEnumerator schemaIt = tree.GetUnmodifiableChildren().GetEnumerator();
while (schemaIt.MoveNext())
{
XMPNode currSchema = (XMPNode)schemaIt.Current;
if (currSchema == null)
{
continue;
}
if (!currSchema.GetHasAliases())
{
continue;
}
List <XMPNode> currPropsToRemove = new List <XMPNode>();
IEnumerator propertyIt = currSchema.IterateChildren();
while (propertyIt.MoveNext())
{
XMPNode currProp = (XMPNode)propertyIt.Current;
if (currProp == null)
{
continue;
}
if (!currProp.IsAlias())
{
continue;
}
currProp.SetAlias(false);
// Find the base path, look for the base schema and root node.
XMPAliasInfo info = XMPMetaFactory.GetSchemaRegistry().FindAlias(currProp.GetName());
if (info != null)
{
// find or create schema
XMPNode baseSchema = XMPNodeUtils.FindSchemaNode(tree, info.GetNamespace(), null, true);
baseSchema.SetImplicit(false);
XMPNode baseNode = XMPNodeUtils.FindChildNode(baseSchema, info.GetPrefix() + info.GetPropName(), false);
if (baseNode == null)
{
if (info.GetAliasForm().IsSimple())
{
// A top-to-top alias, transplant the property.
// change the alias property name to the base name
string qname = info.GetPrefix() + info.GetPropName();
currProp.SetName(qname);
baseSchema.AddChild(currProp);
}
else
{
// An alias to an array item,
// create the array and transplant the property.
baseNode = new XMPNode(info.GetPrefix() + info.GetPropName(),
info.GetAliasForm().ToPropertyOptions());
baseSchema.AddChild(baseNode);
TransplantArrayItemAlias(currProp, baseNode);
}
currPropsToRemove.Add(currProp);
}
else if (info.GetAliasForm().IsSimple())
{
// The base node does exist and this is a top-to-top alias.
// Check for conflicts if strict aliasing is on.
// Remove and delete the alias subtree.
if (strictAliasing)
{
CompareAliasedSubtrees(currProp, baseNode, true);
}
currPropsToRemove.Add(currProp);
}
else
{
// This is an alias to an array item and the array exists.
// Look for the aliased item.
// Then transplant or check & delete as appropriate.
XMPNode itemNode = null;
if (info.GetAliasForm().IsArrayAltText())
{
int xdIndex = XMPNodeUtils.LookupLanguageItem(baseNode, XMPConst.X_DEFAULT);
if (xdIndex != -1)
{
itemNode = baseNode.GetChild(xdIndex);
}
}
else if (baseNode.HasChildren())
{
itemNode = baseNode.GetChild(1);
}
if (itemNode == null)
{
TransplantArrayItemAlias(currProp, baseNode);
}
else
{
if (strictAliasing)
{
CompareAliasedSubtrees(currProp, itemNode, true);
}
}
currPropsToRemove.Add(currProp);
}
}
}
foreach (XMPNode o in currPropsToRemove)
{
currSchema.RemoveChild(o);
}
currPropsToRemove.Clear();
currSchema.SetHasAliases(false);
}
}
public virtual String GetObjectName()
{
return tree.GetName() != null ? tree.GetName() : "";
}