/// <summary>Appends a language item to an alt text array.</summary>
/// <param name="arrayNode">the language array</param>
/// <param name="itemLang">the language of the item</param>
/// <param name="itemValue">the content of the item</param>
/// <exception cref="Com.Adobe.Xmp.XMPException">Thrown if a duplicate property is added</exception>
internal static void AppendLangItem(XMPNode arrayNode, string itemLang, string itemValue)
{
XMPNode newItem = new XMPNode(XMPConstConstants.ArrayItemName, itemValue, null);
XMPNode langQual = new XMPNode(XMPConstConstants.XmlLang, itemLang, null);
newItem.AddQualifier(langQual);
if (!XMPConstConstants.XDefault.Equals(langQual.GetValue()))
{
arrayNode.AddChild(newItem);
}
else
{
arrayNode.AddChild(1, newItem);
}
}
/// <summary>Fixes the GPS Timestamp in EXIF.</summary>
/// <param name="exifSchema">the EXIF schema node</param>
/// <exception cref="Com.Adobe.Xmp.XMPException">Thrown if the date conversion fails.</exception>
private static void FixGPSTimeStamp(XMPNode exifSchema)
{
// Note: if dates are not found the convert-methods throws an exceptions,
// and this methods returns.
XMPNode gpsDateTime = XMPNodeUtils.FindChildNode(exifSchema, "exif:GPSTimeStamp", false);
if (gpsDateTime == null)
{
return;
}
try
{
XMPDateTime binGPSStamp;
XMPDateTime binOtherDate;
binGPSStamp = XMPUtils.ConvertToDate(gpsDateTime.GetValue());
if (binGPSStamp.GetYear() != 0 || binGPSStamp.GetMonth() != 0 || binGPSStamp.GetDay() != 0)
{
return;
}
XMPNode otherDate = XMPNodeUtils.FindChildNode(exifSchema, "exif:DateTimeOriginal", false);
if (otherDate == null)
{
otherDate = XMPNodeUtils.FindChildNode(exifSchema, "exif:DateTimeDigitized", false);
}
binOtherDate = XMPUtils.ConvertToDate(otherDate.GetValue());
Sharpen.Calendar cal = binGPSStamp.GetCalendar();
cal.Set(Sharpen.CalendarEnum.Year, binOtherDate.GetYear());
cal.Set(Sharpen.CalendarEnum.Month, binOtherDate.GetMonth());
cal.Set(Sharpen.CalendarEnum.DayOfMonth, binOtherDate.GetDay());
binGPSStamp = new XMPDateTimeImpl(cal);
gpsDateTime.SetValue(XMPUtils.ConvertFromDate(binGPSStamp));
}
catch (XMPException)
{
// Don't let a missing or bad date stop other things.
return;
}
}
/// <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="Com.Adobe.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", XMPErrorConstants.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", XMPErrorConstants.Badxmp);
}
for (Iterator an = aliasNode.IterateChildren(), bn = baseNode.IterateChildren(); an.HasNext() && bn.HasNext();)
{
XMPNode aliasChild = (XMPNode)an.Next();
XMPNode baseChild = (XMPNode)bn.Next();
CompareAliasedSubtrees(aliasChild, baseChild, false);
}
for (Iterator an_1 = aliasNode.IterateQualifier(), bn_1 = baseNode.IterateQualifier(); an_1.HasNext() && bn_1.HasNext();)
{
XMPNode aliasQual = (XMPNode)an_1.Next();
XMPNode baseQual = (XMPNode)bn_1.Next();
CompareAliasedSubtrees(aliasQual, baseQual, false);
}
}
/// <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="Com.Adobe.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", XMPErrorConstants.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", XMPErrorConstants.Badxmp);
}
for (Iterator an = aliasNode.IterateChildren(), bn = baseNode.IterateChildren(); an.HasNext() && bn.HasNext(); )
{
XMPNode aliasChild = (XMPNode)an.Next();
XMPNode baseChild = (XMPNode)bn.Next();
CompareAliasedSubtrees(aliasChild, baseChild, false);
}
for (Iterator an_1 = aliasNode.IterateQualifier(), bn_1 = baseNode.IterateQualifier(); an_1.HasNext() && bn_1.HasNext(); )
{
XMPNode aliasQual = (XMPNode)an_1.Next();
XMPNode baseQual = (XMPNode)bn_1.Next();
CompareAliasedSubtrees(aliasQual, baseQual, false);
}
}
/// <summary>Make sure that the array is well-formed AltText.</summary>
/// <remarks>
/// Make sure that the array is well-formed AltText. Each item must be simple
/// and have an "xml:lang" qualifier. If repairs are needed, keep simple
/// non-empty items by adding the "xml:lang" with value "x-repair".
/// </remarks>
/// <param name="arrayNode">the property node of the array to repair.</param>
/// <exception cref="Com.Adobe.Xmp.XMPException">Forwards unexpected exceptions.</exception>
private static void RepairAltText(XMPNode arrayNode)
{
if (arrayNode == null || !arrayNode.GetOptions().IsArray())
{
// Already OK or not even an array.
return;
}
// fix options
arrayNode.GetOptions().SetArrayOrdered(true).SetArrayAlternate(true).SetArrayAltText(true);
for (Iterator it = arrayNode.IterateChildren(); it.HasNext();)
{
XMPNode currChild = (XMPNode)it.Next();
if (currChild.GetOptions().IsCompositeProperty())
{
// Delete non-simple children.
it.Remove();
}
else
{
if (!currChild.GetOptions().GetHasLanguage())
{
string childValue = currChild.GetValue();
if (childValue == null || childValue.Length == 0)
{
// Delete empty valued children that have no xml:lang.
it.Remove();
}
else
{
// Add an xml:lang qualifier with the value "x-repair".
XMPNode repairLang = new XMPNode(XMPConstConstants.XmlLang, "x-repair", null);
currChild.AddQualifier(repairLang);
}
}
}
}
}
/// <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="Com.Adobe.Xmp.XMPException"></exception>
private static int LookupQualSelector(XMPNode arrayNode, string qualName, string qualValue, int aliasForm)
{
if (XMPConstConstants.XmlLang.Equals(qualName))
{
qualValue = Utils.NormalizeLangValue(qualValue);
int index = Com.Adobe.Xmp.Impl.XMPNodeUtils.LookupLanguageItem(arrayNode, qualValue);
if (index < 0 && (aliasForm & AliasOptions.PropArrayAltText) > 0)
{
XMPNode langNode = new XMPNode(XMPConstConstants.ArrayItemName, null);
XMPNode xdefault = new XMPNode(XMPConstConstants.XmlLang, XMPConstConstants.XDefault, 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 (Iterator it = currItem.IterateQualifier(); it.HasNext();)
{
XMPNode qualifier = (XMPNode)it.Next();
if (qualName.Equals(qualifier.GetName()) && qualValue.Equals(qualifier.GetValue()))
{
return(index);
}
}
}
return(-1);
}
}
/// <summary>Compares two nodes including its children and qualifier.</summary>
/// <param name="leftNode">an <code>XMPNode</code></param>
/// <param name="rightNode">an <code>XMPNode</code></param>
/// <returns>Returns true if the nodes are equal, false otherwise.</returns>
/// <exception cref="Com.Adobe.Xmp.XMPException">Forwards exceptions to the calling method.</exception>
private static bool ItemValuesMatch(XMPNode leftNode, XMPNode rightNode)
{
PropertyOptions leftForm = leftNode.GetOptions();
PropertyOptions rightForm = rightNode.GetOptions();
if (leftForm.Equals(rightForm))
{
return(false);
}
if (leftForm.GetOptions() == 0)
{
// Simple nodes, check the values and xml:lang qualifiers.
if (!leftNode.GetValue().Equals(rightNode.GetValue()))
{
return(false);
}
if (leftNode.GetOptions().GetHasLanguage() != rightNode.GetOptions().GetHasLanguage())
{
return(false);
}
if (leftNode.GetOptions().GetHasLanguage() && !leftNode.GetQualifier(1).GetValue().Equals(rightNode.GetQualifier(1).GetValue()))
{
return(false);
}
}
else
{
if (leftForm.IsStruct())
{
// Struct nodes, see if all fields match, ignoring order.
if (leftNode.GetChildrenLength() != rightNode.GetChildrenLength())
{
return(false);
}
for (Iterator it = leftNode.IterateChildren(); it.HasNext();)
{
XMPNode leftField = (XMPNode)it.Next();
XMPNode rightField = XMPNodeUtils.FindChildNode(rightNode, leftField.GetName(), false);
if (rightField == null || !ItemValuesMatch(leftField, rightField))
{
return(false);
}
}
}
else
{
// Array nodes, see if the "leftNode" values are present in the
// "rightNode", ignoring order, duplicates,
// and extra values in the rightNode-> The rightNode is the
// destination for AppendProperties.
System.Diagnostics.Debug.Assert(leftForm.IsArray());
for (Iterator il = leftNode.IterateChildren(); il.HasNext();)
{
XMPNode leftItem = (XMPNode)il.Next();
bool match = false;
for (Iterator ir = rightNode.IterateChildren(); ir.HasNext();)
{
XMPNode rightItem = (XMPNode)ir.Next();
if (ItemValuesMatch(leftItem, rightItem))
{
match = true;
break;
}
}
if (!match)
{
return(false);
}
}
}
}
return(true);
}
/// <seealso cref="AppendProperties(Com.Adobe.Xmp.XMPMeta, Com.Adobe.Xmp.XMPMeta, bool, bool, bool)"/>
/// <param name="destXMP">The destination XMP object.</param>
/// <param name="sourceNode">the source node</param>
/// <param name="destParent">the parent of the destination node</param>
/// <param name="replaceOldValues">Replace the values of existing properties.</param>
/// <param name="deleteEmptyValues">
/// flag if properties with empty values should be deleted
/// in the destination object.
/// </param>
/// <exception cref="Com.Adobe.Xmp.XMPException"/>
private static void AppendSubtree(XMPMetaImpl destXMP, XMPNode sourceNode, XMPNode destParent, bool replaceOldValues, bool deleteEmptyValues)
{
XMPNode destNode = XMPNodeUtils.FindChildNode(destParent, sourceNode.GetName(), false);
bool valueIsEmpty = false;
if (deleteEmptyValues)
{
valueIsEmpty = sourceNode.GetOptions().IsSimple() ? sourceNode.GetValue() == null || sourceNode.GetValue().Length == 0 : !sourceNode.HasChildren();
}
if (deleteEmptyValues && valueIsEmpty)
{
if (destNode != null)
{
destParent.RemoveChild(destNode);
}
}
else
{
if (destNode == null)
{
// The one easy case, the destination does not exist.
destParent.AddChild((XMPNode)sourceNode.Clone());
}
else
{
if (replaceOldValues)
{
// The destination exists and should be replaced.
destXMP.SetNode(destNode, sourceNode.GetValue(), sourceNode.GetOptions(), true);
destParent.RemoveChild(destNode);
destNode = (XMPNode)sourceNode.Clone();
destParent.AddChild(destNode);
}
else
{
// The destination exists and is not totally replaced. Structs and
// arrays are merged.
PropertyOptions sourceForm = sourceNode.GetOptions();
PropertyOptions destForm = destNode.GetOptions();
if (sourceForm != destForm)
{
return;
}
if (sourceForm.IsStruct())
{
// To merge a struct process the fields recursively. E.g. add simple missing fields.
// The recursive call to AppendSubtree will handle deletion for fields with empty
// values.
for (Iterator it = sourceNode.IterateChildren(); it.HasNext();)
{
XMPNode sourceField = (XMPNode)it.Next();
AppendSubtree(destXMP, sourceField, destNode, replaceOldValues, deleteEmptyValues);
if (deleteEmptyValues && !destNode.HasChildren())
{
destParent.RemoveChild(destNode);
}
}
}
else
{
if (sourceForm.IsArrayAltText())
{
// Merge AltText arrays by the "xml:lang" qualifiers. Make sure x-default is first.
// Make a special check for deletion of empty values. Meaningful in AltText arrays
// because the "xml:lang" qualifier provides unambiguous source/dest correspondence.
for (Iterator it = sourceNode.IterateChildren(); it.HasNext();)
{
XMPNode sourceItem = (XMPNode)it.Next();
if (!sourceItem.HasQualifier() || !XMPConstConstants.XmlLang.Equals(sourceItem.GetQualifier(1).GetName()))
{
continue;
}
int destIndex = XMPNodeUtils.LookupLanguageItem(destNode, sourceItem.GetQualifier(1).GetValue());
if (deleteEmptyValues && (sourceItem.GetValue() == null || sourceItem.GetValue().Length == 0))
{
if (destIndex != -1)
{
destNode.RemoveChild(destIndex);
if (!destNode.HasChildren())
{
destParent.RemoveChild(destNode);
}
}
}
else
{
if (destIndex == -1)
{
// Not replacing, keep the existing item.
if (!XMPConstConstants.XDefault.Equals(sourceItem.GetQualifier(1).GetValue()) || !destNode.HasChildren())
{
sourceItem.CloneSubtree(destNode);
}
else
{
XMPNode destItem = new XMPNode(sourceItem.GetName(), sourceItem.GetValue(), sourceItem.GetOptions());
sourceItem.CloneSubtree(destItem);
destNode.AddChild(1, destItem);
}
}
}
}
}
else
{
if (sourceForm.IsArray())
{
// Merge other arrays by item values. Don't worry about order or duplicates. Source
// items with empty values do not cause deletion, that conflicts horribly with
// merging.
for (Iterator @is = sourceNode.IterateChildren(); @is.HasNext();)
{
XMPNode sourceItem = (XMPNode)@is.Next();
bool match = false;
for (Iterator id = destNode.IterateChildren(); id.HasNext();)
{
XMPNode destItem = (XMPNode)id.Next();
if (ItemValuesMatch(sourceItem, destItem))
{
match = true;
}
}
if (!match)
{
destNode = (XMPNode)sourceItem.Clone();
destParent.AddChild(destNode);
}
}
}
}
}
}
}
}
}
/// <summary>Compares two nodes including its children and qualifier.</summary>
/// <param name="leftNode">an <code>XMPNode</code></param>
/// <param name="rightNode">an <code>XMPNode</code></param>
/// <returns>Returns true if the nodes are equal, false otherwise.</returns>
/// <exception cref="Com.Adobe.Xmp.XMPException">Forwards exceptions to the calling method.</exception>
private static bool ItemValuesMatch(XMPNode leftNode, XMPNode rightNode)
{
PropertyOptions leftForm = leftNode.GetOptions();
PropertyOptions rightForm = rightNode.GetOptions();
if (leftForm.Equals(rightForm))
{
return false;
}
if (leftForm.GetOptions() == 0)
{
// Simple nodes, check the values and xml:lang qualifiers.
if (!leftNode.GetValue().Equals(rightNode.GetValue()))
{
return false;
}
if (leftNode.GetOptions().GetHasLanguage() != rightNode.GetOptions().GetHasLanguage())
{
return false;
}
if (leftNode.GetOptions().GetHasLanguage() && !leftNode.GetQualifier(1).GetValue().Equals(rightNode.GetQualifier(1).GetValue()))
{
return false;
}
}
else
{
if (leftForm.IsStruct())
{
// Struct nodes, see if all fields match, ignoring order.
if (leftNode.GetChildrenLength() != rightNode.GetChildrenLength())
{
return false;
}
for (Iterator it = leftNode.IterateChildren(); it.HasNext(); )
{
XMPNode leftField = (XMPNode)it.Next();
XMPNode rightField = XMPNodeUtils.FindChildNode(rightNode, leftField.GetName(), false);
if (rightField == null || !ItemValuesMatch(leftField, rightField))
{
return false;
}
}
}
else
{
// Array nodes, see if the "leftNode" values are present in the
// "rightNode", ignoring order, duplicates,
// and extra values in the rightNode-> The rightNode is the
// destination for AppendProperties.
System.Diagnostics.Debug.Assert(leftForm.IsArray());
for (Iterator il = leftNode.IterateChildren(); il.HasNext(); )
{
XMPNode leftItem = (XMPNode)il.Next();
bool match = false;
for (Iterator ir = rightNode.IterateChildren(); ir.HasNext(); )
{
XMPNode rightItem = (XMPNode)ir.Next();
if (ItemValuesMatch(leftItem, rightItem))
{
match = true;
break;
}
}
if (!match)
{
return false;
}
}
}
}
return true;
}
/// <summary>Writes all used namespaces of the subtree in node to the output.</summary>
/// <remarks>
/// Writes all used namespaces of the subtree in node to the output.
/// The subtree is recursivly traversed.
/// </remarks>
/// <param name="node">the root node of the subtree</param>
/// <param name="usedPrefixes">a set containing currently used prefixes</param>
/// <param name="indent">the current indent level</param>
/// <exception cref="System.IO.IOException">Forwards all writer exceptions.</exception>
private void DeclareUsedNamespaces(XMPNode node, HashSet<string> usedPrefixes, int indent)
{
if (node.GetOptions().IsSchemaNode())
{
// The schema node name is the URI, the value is the prefix.
string prefix = Sharpen.Runtime.Substring(node.GetValue(), 0, node.GetValue().Length - 1);
DeclareNamespace(prefix, node.GetName(), usedPrefixes, indent);
}
else
{
if (node.GetOptions().IsStruct())
{
for (Iterator it = node.IterateChildren(); it.HasNext(); )
{
XMPNode field = (XMPNode)it.Next();
DeclareNamespace(field.GetName(), null, usedPrefixes, indent);
}
}
}
for (Iterator it_1 = node.IterateChildren(); it_1.HasNext(); )
{
XMPNode child = (XMPNode)it_1.Next();
DeclareUsedNamespaces(child, usedPrefixes, indent);
}
for (Iterator it_2 = node.IterateQualifier(); it_2.HasNext(); )
{
XMPNode qualifier = (XMPNode)it_2.Next();
DeclareNamespace(qualifier.GetName(), null, usedPrefixes, indent);
DeclareUsedNamespaces(qualifier, usedPrefixes, indent);
}
}
/// <summary>
/// The initial support for WAV files mapped a legacy ID3 audio copyright
/// into a new xmpDM:copyright property.
/// </summary>
/// <remarks>
/// The initial support for WAV files mapped a legacy ID3 audio copyright
/// into a new xmpDM:copyright property. This is special case code to migrate
/// that into dc:rights['x-default']. The rules:
/// <pre>
/// 1. If there is no dc:rights array, or an empty array -
/// Create one with dc:rights['x-default'] set from double linefeed and xmpDM:copyright.
/// 2. If there is a dc:rights array but it has no x-default item -
/// Create an x-default item as a copy of the first item then apply rule #3.
/// 3. If there is a dc:rights array with an x-default item,
/// Look for a double linefeed in the value.
/// A. If no double linefeed, compare the x-default value to the xmpDM:copyright value.
/// A1. If they match then leave the x-default value alone.
/// A2. Otherwise, append a double linefeed and
/// the xmpDM:copyright value to the x-default value.
/// B. If there is a double linefeed, compare the trailing text to the xmpDM:copyright value.
/// B1. If they match then leave the x-default value alone.
/// B2. Otherwise, replace the trailing x-default text with the xmpDM:copyright value.
/// 4. In all cases, delete the xmpDM:copyright property.
/// </pre>
/// </remarks>
/// <param name="xmp">the metadata object</param>
/// <param name="dmCopyright">the "dm:copyright"-property</param>
private static void MigrateAudioCopyright(XMPMeta xmp, XMPNode dmCopyright)
{
try
{
XMPNode dcSchema = XMPNodeUtils.FindSchemaNode(((XMPMetaImpl)xmp).GetRoot(), XMPConstConstants.NsDc, true);
string dmValue = dmCopyright.GetValue();
string doubleLF = "\n\n";
XMPNode dcRightsArray = XMPNodeUtils.FindChildNode(dcSchema, "dc:rights", false);
if (dcRightsArray == null || !dcRightsArray.HasChildren())
{
// 1. No dc:rights array, create from double linefeed and xmpDM:copyright.
dmValue = doubleLF + dmValue;
xmp.SetLocalizedText(XMPConstConstants.NsDc, "rights", string.Empty, XMPConstConstants.XDefault, dmValue, null);
}
else
{
int xdIndex = XMPNodeUtils.LookupLanguageItem(dcRightsArray, XMPConstConstants.XDefault);
if (xdIndex < 0)
{
// 2. No x-default item, create from the first item.
string firstValue = dcRightsArray.GetChild(1).GetValue();
xmp.SetLocalizedText(XMPConstConstants.NsDc, "rights", string.Empty, XMPConstConstants.XDefault, firstValue, null);
xdIndex = XMPNodeUtils.LookupLanguageItem(dcRightsArray, XMPConstConstants.XDefault);
}
// 3. Look for a double linefeed in the x-default value.
XMPNode defaultNode = dcRightsArray.GetChild(xdIndex);
string defaultValue = defaultNode.GetValue();
int lfPos = defaultValue.IndexOf(doubleLF);
if (lfPos < 0)
{
// 3A. No double LF, compare whole values.
if (!dmValue.Equals(defaultValue))
{
// 3A2. Append the xmpDM:copyright to the x-default
// item.
defaultNode.SetValue(defaultValue + doubleLF + dmValue);
}
}
else
{
// 3B. Has double LF, compare the tail.
if (!Sharpen.Runtime.Substring(defaultValue, lfPos + 2).Equals(dmValue))
{
// 3B2. Replace the x-default tail.
defaultNode.SetValue(Sharpen.Runtime.Substring(defaultValue, 0, lfPos + 2) + dmValue);
}
}
}
// 4. Get rid of the xmpDM:copyright.
dmCopyright.GetParent().RemoveChild(dmCopyright);
}
catch (XMPException)
{
}
}
/// <summary>Creates a property info object from an <code>XMPNode</code>.</summary>
/// <param name="node">an <code>XMPNode</code></param>
/// <param name="baseNS">the base namespace to report</param>
/// <param name="path">the full property path</param>
/// <returns>Returns a <code>XMPProperty</code>-object that serves representation of the node.</returns>
protected internal virtual XMPPropertyInfo CreatePropertyInfo(XMPNode node, string baseNS, string path)
{
string value = node.GetOptions().IsSchemaNode() ? null : node.GetValue();
return(new _XMPPropertyInfo_450(node, baseNS, path, value));
}
/// <summary>Creates a property info object from an <code>XMPNode</code>.</summary>
/// <param name="node">an <code>XMPNode</code></param>
/// <param name="baseNS">the base namespace to report</param>
/// <param name="path">the full property path</param>
/// <returns>Returns a <code>XMPProperty</code>-object that serves representation of the node.</returns>
protected internal virtual XMPPropertyInfo CreatePropertyInfo(XMPNode node, string baseNS, string path)
{
string value = node.GetOptions().IsSchemaNode() ? null : node.GetValue();
return new _XMPPropertyInfo_450(node, baseNS, path, value);
}
/// <summary>Recursively handles the "value" for a node.</summary>
/// <remarks>
/// Recursively handles the "value" for a node. It does not matter if it is a
/// top level property, a field of a struct, or an item of an array. The
/// indent is that for the property element. An xml:lang qualifier is written
/// as an attribute of the property start tag, not by itself forcing the
/// qualified property form. The patterns below mostly ignore attribute
/// qualifiers like xml:lang. Except for the one struct case, attribute
/// qualifiers don't affect the output form.
/// <blockquote>
/// <pre>
/// <ns:UnqualifiedSimpleProperty>value</ns:UnqualifiedSimpleProperty>
/// <ns:UnqualifiedStructProperty> (If no rdf:resource qualifier)
/// <rdf:Description>
/// ... Fields, same forms as top level properties
/// </rdf:Description>
/// </ns:UnqualifiedStructProperty>
/// <ns:ResourceStructProperty rdf:resource="URI"
/// ... Fields as attributes
/// >
/// <ns:UnqualifiedArrayProperty>
/// <rdf:Bag> or Seq or Alt
/// ... Array items as rdf:li elements, same forms as top level properties
/// </rdf:Bag>
/// </ns:UnqualifiedArrayProperty>
/// <ns:QualifiedProperty>
/// <rdf:Description>
/// <rdf:value> ... Property "value" following the unqualified
/// forms ... </rdf:value>
/// ... Qualifiers looking like named struct fields
/// </rdf:Description>
/// </ns:QualifiedProperty>
/// </pre>
/// </blockquote>
/// </remarks>
/// <param name="node">the property node</param>
/// <param name="emitAsRDFValue">property shall be rendered as attribute rather than tag</param>
/// <param name="useCanonicalRDF">
/// use canonical form with inner description tag or
/// the compact form with rdf:ParseType="resource" attribute.
/// </param>
/// <param name="indent">the current indent level</param>
/// <exception cref="System.IO.IOException">Forwards all writer exceptions.</exception>
/// <exception cref="Com.Adobe.Xmp.XMPException">If "rdf:resource" and general qualifiers are mixed.</exception>
private void SerializeCanonicalRDFProperty(XMPNode node, bool useCanonicalRDF, bool emitAsRDFValue, int indent)
{
bool emitEndTag = true;
bool indentEndTag = true;
// Determine the XML element name. Open the start tag with the name and
// attribute qualifiers.
string elemName = node.GetName();
if (emitAsRDFValue)
{
elemName = "rdf:value";
}
else
{
if (XMPConstConstants.ArrayItemName.Equals(elemName))
{
elemName = "rdf:li";
}
}
WriteIndent(indent);
Write('<');
Write(elemName);
bool hasGeneralQualifiers = false;
bool hasRDFResourceQual = false;
for (Iterator it = node.IterateQualifier(); it.HasNext(); )
{
XMPNode qualifier = (XMPNode)it.Next();
if (!RdfAttrQualifier.Contains(qualifier.GetName()))
{
hasGeneralQualifiers = true;
}
else
{
hasRDFResourceQual = "rdf:resource".Equals(qualifier.GetName());
if (!emitAsRDFValue)
{
Write(' ');
Write(qualifier.GetName());
Write("=\"");
AppendNodeValue(qualifier.GetValue(), true);
Write('"');
}
}
}
// Process the property according to the standard patterns.
if (hasGeneralQualifiers && !emitAsRDFValue)
{
// This node has general, non-attribute, qualifiers. Emit using the
// qualified property form.
// ! The value is output by a recursive call ON THE SAME NODE with
// emitAsRDFValue set.
if (hasRDFResourceQual)
{
throw new XMPException("Can't mix rdf:resource and general qualifiers", XMPErrorConstants.Badrdf);
}
// Change serialization to canonical format with inner rdf:Description-tag
// depending on option
if (useCanonicalRDF)
{
Write(">");
WriteNewline();
indent++;
WriteIndent(indent);
Write(RdfStructStart);
Write(">");
}
else
{
Write(" rdf:parseType=\"Resource\">");
}
WriteNewline();
SerializeCanonicalRDFProperty(node, useCanonicalRDF, true, indent + 1);
for (Iterator it_1 = node.IterateQualifier(); it_1.HasNext(); )
{
XMPNode qualifier = (XMPNode)it_1.Next();
if (!RdfAttrQualifier.Contains(qualifier.GetName()))
{
SerializeCanonicalRDFProperty(qualifier, useCanonicalRDF, false, indent + 1);
}
}
if (useCanonicalRDF)
{
WriteIndent(indent);
Write(RdfStructEnd);
WriteNewline();
indent--;
}
}
else
{
// This node has no general qualifiers. Emit using an unqualified form.
if (!node.GetOptions().IsCompositeProperty())
{
// This is a simple property.
if (node.GetOptions().IsURI())
{
Write(" rdf:resource=\"");
AppendNodeValue(node.GetValue(), true);
Write("\"/>");
WriteNewline();
emitEndTag = false;
}
else
{
if (node.GetValue() == null || string.Empty.Equals(node.GetValue()))
{
Write("/>");
WriteNewline();
emitEndTag = false;
}
else
{
Write('>');
AppendNodeValue(node.GetValue(), false);
indentEndTag = false;
}
}
}
else
{
if (node.GetOptions().IsArray())
{
// This is an array.
Write('>');
WriteNewline();
EmitRDFArrayTag(node, true, indent + 1);
if (node.GetOptions().IsArrayAltText())
{
XMPNodeUtils.NormalizeLangArray(node);
}
for (Iterator it_1 = node.IterateChildren(); it_1.HasNext(); )
{
XMPNode child = (XMPNode)it_1.Next();
SerializeCanonicalRDFProperty(child, useCanonicalRDF, false, indent + 2);
}
EmitRDFArrayTag(node, false, indent + 1);
}
else
{
if (!hasRDFResourceQual)
{
// This is a "normal" struct, use the rdf:parseType="Resource" form.
if (!node.HasChildren())
{
// Change serialization to canonical format with inner rdf:Description-tag
// if option is set
if (useCanonicalRDF)
{
Write(">");
WriteNewline();
WriteIndent(indent + 1);
Write(RdfEmptyStruct);
}
else
{
Write(" rdf:parseType=\"Resource\"/>");
emitEndTag = false;
}
WriteNewline();
}
else
{
// Change serialization to canonical format with inner rdf:Description-tag
// if option is set
if (useCanonicalRDF)
{
Write(">");
WriteNewline();
indent++;
WriteIndent(indent);
Write(RdfStructStart);
Write(">");
}
else
{
Write(" rdf:parseType=\"Resource\">");
}
WriteNewline();
for (Iterator it_1 = node.IterateChildren(); it_1.HasNext(); )
{
XMPNode child = (XMPNode)it_1.Next();
SerializeCanonicalRDFProperty(child, useCanonicalRDF, false, indent + 1);
}
if (useCanonicalRDF)
{
WriteIndent(indent);
Write(RdfStructEnd);
WriteNewline();
indent--;
}
}
}
else
{
// This is a struct with an rdf:resource attribute, use the
// "empty property element" form.
for (Iterator it_1 = node.IterateChildren(); it_1.HasNext(); )
{
XMPNode child = (XMPNode)it_1.Next();
if (!CanBeRDFAttrProp(child))
{
throw new XMPException("Can't mix rdf:resource and complex fields", XMPErrorConstants.Badrdf);
}
WriteNewline();
WriteIndent(indent + 1);
Write(' ');
Write(child.GetName());
Write("=\"");
AppendNodeValue(child.GetValue(), true);
Write('"');
}
Write("/>");
WriteNewline();
emitEndTag = false;
}
}
}
}
// Emit the property element end tag.
if (emitEndTag)
{
if (indentEndTag)
{
WriteIndent(indent);
}
Write("</");
Write(elemName);
Write('>');
WriteNewline();
}
}
/// <summary>
/// Evaluates a raw node value to the given value type, apply special
/// conversions for defined types in XMP.
/// </summary>
/// <param name="valueType">an int indicating the value type</param>
/// <param name="propNode">the node containing the value</param>
/// <returns>Returns a literal value for the node.</returns>
/// <exception cref="Com.Adobe.Xmp.XMPException"/>
private object EvaluateNodeValue(int valueType, XMPNode propNode)
{
object value;
string rawValue = propNode.GetValue();
switch (valueType)
{
case ValueBoolean:
{
value = XMPUtils.ConvertToBoolean(rawValue);
break;
}
case ValueInteger:
{
value = XMPUtils.ConvertToInteger(rawValue);
break;
}
case ValueLong:
{
value = XMPUtils.ConvertToLong(rawValue);
break;
}
case ValueDouble:
{
value = XMPUtils.ConvertToDouble(rawValue);
break;
}
case ValueDate:
{
value = XMPUtils.ConvertToDate(rawValue);
break;
}
case ValueCalendar:
{
XMPDateTime dt = XMPUtils.ConvertToDate(rawValue);
value = dt.GetCalendar();
break;
}
case ValueBase64:
{
value = XMPUtils.DecodeBase64(rawValue);
break;
}
case ValueString:
default:
{
// leaf values return empty string instead of null
// for the other cases the converter methods provides a "null"
// value.
// a default value can only occur if this method is made public.
value = rawValue != null || propNode.GetOptions().IsCompositeProperty() ? rawValue : string.Empty;
break;
}
}
return value;
}
/// <seealso cref="AppendProperties(Com.Adobe.Xmp.XMPMeta, Com.Adobe.Xmp.XMPMeta, bool, bool, bool)"/>
/// <param name="destXMP">The destination XMP object.</param>
/// <param name="sourceNode">the source node</param>
/// <param name="destParent">the parent of the destination node</param>
/// <param name="replaceOldValues">Replace the values of existing properties.</param>
/// <param name="deleteEmptyValues">
/// flag if properties with empty values should be deleted
/// in the destination object.
/// </param>
/// <exception cref="Com.Adobe.Xmp.XMPException"/>
private static void AppendSubtree(XMPMetaImpl destXMP, XMPNode sourceNode, XMPNode destParent, bool replaceOldValues, bool deleteEmptyValues)
{
XMPNode destNode = XMPNodeUtils.FindChildNode(destParent, sourceNode.GetName(), false);
bool valueIsEmpty = false;
if (deleteEmptyValues)
{
valueIsEmpty = sourceNode.GetOptions().IsSimple() ? sourceNode.GetValue() == null || sourceNode.GetValue().Length == 0 : !sourceNode.HasChildren();
}
if (deleteEmptyValues && valueIsEmpty)
{
if (destNode != null)
{
destParent.RemoveChild(destNode);
}
}
else
{
if (destNode == null)
{
// The one easy case, the destination does not exist.
destParent.AddChild((XMPNode)sourceNode.Clone());
}
else
{
if (replaceOldValues)
{
// The destination exists and should be replaced.
destXMP.SetNode(destNode, sourceNode.GetValue(), sourceNode.GetOptions(), true);
destParent.RemoveChild(destNode);
destNode = (XMPNode)sourceNode.Clone();
destParent.AddChild(destNode);
}
else
{
// The destination exists and is not totally replaced. Structs and
// arrays are merged.
PropertyOptions sourceForm = sourceNode.GetOptions();
PropertyOptions destForm = destNode.GetOptions();
if (sourceForm != destForm)
{
return;
}
if (sourceForm.IsStruct())
{
// To merge a struct process the fields recursively. E.g. add simple missing fields.
// The recursive call to AppendSubtree will handle deletion for fields with empty
// values.
for (Iterator it = sourceNode.IterateChildren(); it.HasNext(); )
{
XMPNode sourceField = (XMPNode)it.Next();
AppendSubtree(destXMP, sourceField, destNode, replaceOldValues, deleteEmptyValues);
if (deleteEmptyValues && !destNode.HasChildren())
{
destParent.RemoveChild(destNode);
}
}
}
else
{
if (sourceForm.IsArrayAltText())
{
// Merge AltText arrays by the "xml:lang" qualifiers. Make sure x-default is first.
// Make a special check for deletion of empty values. Meaningful in AltText arrays
// because the "xml:lang" qualifier provides unambiguous source/dest correspondence.
for (Iterator it = sourceNode.IterateChildren(); it.HasNext(); )
{
XMPNode sourceItem = (XMPNode)it.Next();
if (!sourceItem.HasQualifier() || !XMPConstConstants.XmlLang.Equals(sourceItem.GetQualifier(1).GetName()))
{
continue;
}
int destIndex = XMPNodeUtils.LookupLanguageItem(destNode, sourceItem.GetQualifier(1).GetValue());
if (deleteEmptyValues && (sourceItem.GetValue() == null || sourceItem.GetValue().Length == 0))
{
if (destIndex != -1)
{
destNode.RemoveChild(destIndex);
if (!destNode.HasChildren())
{
destParent.RemoveChild(destNode);
}
}
}
else
{
if (destIndex == -1)
{
// Not replacing, keep the existing item.
if (!XMPConstConstants.XDefault.Equals(sourceItem.GetQualifier(1).GetValue()) || !destNode.HasChildren())
{
sourceItem.CloneSubtree(destNode);
}
else
{
XMPNode destItem = new XMPNode(sourceItem.GetName(), sourceItem.GetValue(), sourceItem.GetOptions());
sourceItem.CloneSubtree(destItem);
destNode.AddChild(1, destItem);
}
}
}
}
}
else
{
if (sourceForm.IsArray())
{
// Merge other arrays by item values. Don't worry about order or duplicates. Source
// items with empty values do not cause deletion, that conflicts horribly with
// merging.
for (Iterator @is = sourceNode.IterateChildren(); @is.HasNext(); )
{
XMPNode sourceItem = (XMPNode)@is.Next();
bool match = false;
for (Iterator id = destNode.IterateChildren(); id.HasNext(); )
{
XMPNode destItem = (XMPNode)id.Next();
if (ItemValuesMatch(sourceItem, destItem))
{
match = true;
}
}
if (!match)
{
destNode = (XMPNode)sourceItem.Clone();
destParent.AddChild(destNode);
}
}
}
}
}
}
}
}
}
/// <summary>Serializes a simple property.</summary>
/// <param name="node">an XMPNode</param>
/// <returns>Returns an array containing the flags emitEndTag and indentEndTag.</returns>
/// <exception cref="System.IO.IOException">Forwards the writer exceptions.</exception>
private object[] SerializeCompactRDFSimpleProp(XMPNode node)
{
// This is a simple property.
bool emitEndTag = true;
bool indentEndTag = true;
if (node.GetOptions().IsURI())
{
Write(" rdf:resource=\"");
AppendNodeValue(node.GetValue(), true);
Write("\"/>");
WriteNewline();
emitEndTag = false;
}
else
{
if (node.GetValue() == null || node.GetValue().Length == 0)
{
Write("/>");
WriteNewline();
emitEndTag = false;
}
else
{
Write('>');
AppendNodeValue(node.GetValue(), false);
indentEndTag = false;
}
}
return new object[] { emitEndTag, indentEndTag };
}
