/// <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(), XMPConst
.NS_DC, 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(XMPConst.NS_DC, "rights", "", XMPConst.X_DEFAULT, dmValue, null
);
}
else
{
int xdIndex = XMPNodeUtils.LookupLanguageItem(dcRightsArray, XMPConst.X_DEFAULT);
if (xdIndex < 0)
{
// 2. No x-default item, create from the first item.
String firstValue = dcRightsArray.GetChild(1).GetValue();
xmp.SetLocalizedText(XMPConst.NS_DC, "rights", "", XMPConst.X_DEFAULT, firstValue
, null);
xdIndex = XMPNodeUtils.LookupLanguageItem(dcRightsArray, XMPConst.X_DEFAULT);
}
// 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 (!defaultValue.Substring(lfPos + 2).Equals(dmValue))
{
// 3B2. Replace the x-default tail.
defaultNode.SetValue(defaultValue.JSubstring(0, lfPos + 2) + dmValue);
}
}
}
// 4. Get rid of the xmpDM:copyright.
dmCopyright.GetParent().RemoveChild(dmCopyright);
}
catch (XMPException)
{
}
}
/// <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>Find or create a schema node if <code>createNodes</code> is true.</summary>
/// <param name="tree">the root of the xmp tree.</param>
/// <param name="namespaceURI">a namespace</param>
/// <param name="suggestedPrefix">If a prefix is suggested, the namespace is allowed to be registered.
/// </param>
/// <param name="createNodes">
/// a flag indicating if the node shall be created if not found.
/// <em>Note:</em> The namespace must be registered prior to this call.
/// </param>
/// <returns>
/// Returns the schema node if found, <code>null</code> otherwise.
/// Note: If <code>createNodes</code> is <code>true</code>, it is <b>always</b>
/// returned a valid node.
/// </returns>
/// <exception cref="iText.Kernel.XMP.XMPException">
/// An exception is only thrown if an error occurred, not if a
/// node was not found.
/// </exception>
internal static XMPNode FindSchemaNode(XMPNode tree, String namespaceURI, String
suggestedPrefix, bool createNodes)
{
System.Diagnostics.Debug.Assert(tree.GetParent() == null);
// make sure that its the root
XMPNode schemaNode = tree.FindChildByName(namespaceURI);
if (schemaNode == null && createNodes)
{
schemaNode = new XMPNode(namespaceURI, new PropertyOptions().SetSchemaNode(true));
schemaNode.SetImplicit(true);
// only previously registered schema namespaces are allowed in the XMP tree.
String prefix = XMPMetaFactory.GetSchemaRegistry().GetNamespacePrefix(namespaceURI
);
if (prefix == null)
{
if (suggestedPrefix != null && suggestedPrefix.Length != 0)
{
prefix = XMPMetaFactory.GetSchemaRegistry().RegisterNamespace(namespaceURI, suggestedPrefix
);
}
else
{
throw new XMPException("Unregistered schema namespace URI", XMPError.BADSCHEMA);
}
}
schemaNode.SetValue(prefix);
tree.AddChild(schemaNode);
}
return(schemaNode);
}
/// <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>Fixes the GPS Timestamp in EXIF.</summary>
/// <param name="exifSchema">the EXIF schema node</param>
/// <exception cref="iText.Kernel.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 = XMPUtils.ConvertToDate(gpsDateTime.GetValue());
if (binGpsStamp.GetYear() != 0 || binGpsStamp.GetMonth() != 0 || binGpsStamp.GetDay() != 0)
{
return;
}
XMPNode otherDate = XMPNodeUtils.FindChildNode(exifSchema, "exif:DateTimeOriginal", false);
otherDate = otherDate ?? XMPNodeUtils.FindChildNode(exifSchema, "exif:DateTimeDigitized", false);
XMPDateTime binOtherDate = XMPUtils.ConvertToDate(otherDate.GetValue());
XMPCalendar cal = binGpsStamp.GetCalendar();
DateTime dt = new DateTime(binOtherDate.GetYear(), binOtherDate.GetMonth(), binOtherDate.GetDay(),
cal.GetDateTime().Hour, cal.GetDateTime().Minute, cal.GetDateTime().Second, cal.GetDateTime().Millisecond);
cal.SetDateTime(dt);
binGpsStamp = new XMPDateTimeImpl(cal);
gpsDateTime.SetValue(XMPUtils.ConvertFromDate(binGpsStamp));
}
catch (XMPException) {
}
}
public virtual void SetLocalizedText(String schemaNS, String altTextName, String
genericLang, String specificLang, String itemValue, PropertyOptions options)
{
ParameterAsserts.AssertSchemaNS(schemaNS);
ParameterAsserts.AssertArrayName(altTextName);
ParameterAsserts.AssertSpecificLang(specificLang);
genericLang = genericLang != null ? iText.Kernel.XMP.Impl.Utils.NormalizeLangValue
(genericLang) : null;
specificLang = iText.Kernel.XMP.Impl.Utils.NormalizeLangValue(specificLang);
XMPPath arrayPath = XMPPathParser.ExpandXPath(schemaNS, altTextName);
// Find the array node and set the options if it was just created.
XMPNode arrayNode = XMPNodeUtils.FindNode(tree, arrayPath, true, new PropertyOptions
(PropertyOptions.ARRAY | PropertyOptions.ARRAY_ORDERED | PropertyOptions.ARRAY_ALTERNATE
| PropertyOptions.ARRAY_ALT_TEXT));
if (arrayNode == null)
{
throw new XMPException("Failed to find or create array node", XMPError.BADXPATH);
}
else
{
if (!arrayNode.GetOptions().IsArrayAltText())
{
if (!arrayNode.HasChildren() && arrayNode.GetOptions().IsArrayAlternate())
{
arrayNode.GetOptions().SetArrayAltText(true);
}
else
{
throw new XMPException("Specified property is no alt-text array", XMPError.BADXPATH
);
}
}
}
// Make sure the x-default item, if any, is first.
bool haveXDefault = false;
XMPNode xdItem = null;
foreach (XMPNode currItem in arrayNode.GetChildren())
{
if (!currItem.HasQualifier() || !XMPConst.XML_LANG.Equals(currItem.GetQualifier(1
).GetName()))
{
throw new XMPException("Language qualifier must be first", XMPError.BADXPATH);
}
else
{
if (XMPConst.X_DEFAULT.Equals(currItem.GetQualifier(1).GetValue()))
{
xdItem = currItem;
haveXDefault = true;
break;
}
}
}
// Moves x-default to the beginning of the array
if (xdItem != null && arrayNode.GetChildrenLength() > 1)
{
arrayNode.RemoveChild(xdItem);
arrayNode.AddChild(1, xdItem);
}
// Find the appropriate item.
// chooseLocalizedText will make sure the array is a language
// alternative.
Object[] result = XMPNodeUtils.ChooseLocalizedText(arrayNode, genericLang, specificLang
);
int match = (int)result[0];
XMPNode itemNode = (XMPNode)result[1];
bool specificXDefault = XMPConst.X_DEFAULT.Equals(specificLang);
switch (match)
{
case XMPNodeUtils.CLT_NO_VALUES:
{
// Create the array items for the specificLang and x-default, with
// x-default first.
XMPNodeUtils.AppendLangItem(arrayNode, XMPConst.X_DEFAULT, itemValue);
haveXDefault = true;
if (!specificXDefault)
{
XMPNodeUtils.AppendLangItem(arrayNode, specificLang, itemValue);
}
break;
}
case XMPNodeUtils.CLT_SPECIFIC_MATCH:
{
if (!specificXDefault)
{
// Update the specific item, update x-default if it matches the
// old value.
if (haveXDefault && xdItem != itemNode && xdItem != null && xdItem.GetValue().Equals
(itemNode.GetValue()))
{
xdItem.SetValue(itemValue);
}
// ! Do this after the x-default check!
itemNode.SetValue(itemValue);
}
else
{
// Update all items whose values match the old x-default value.
System.Diagnostics.Debug.Assert(haveXDefault && xdItem == itemNode);
for (IEnumerator it_1 = arrayNode.IterateChildren(); it_1.MoveNext(); )
{
XMPNode currItem = (XMPNode)it_1.Current;
if (currItem == xdItem || !currItem.GetValue().Equals(xdItem != null ? xdItem.GetValue
() : null))
{
continue;
}
currItem.SetValue(itemValue);
}
// And finally do the x-default item.
if (xdItem != null)
{
xdItem.SetValue(itemValue);
}
}
break;
}
case XMPNodeUtils.CLT_SINGLE_GENERIC:
{
// Update the generic item, update x-default if it matches the old
// value.
if (haveXDefault && xdItem != itemNode && xdItem != null && xdItem.GetValue().Equals
(itemNode.GetValue()))
{
xdItem.SetValue(itemValue);
}
itemNode.SetValue(itemValue);
// ! Do this after
// the x-default
// check!
break;
}
case XMPNodeUtils.CLT_MULTIPLE_GENERIC:
{
// Create the specific language, ignore x-default.
XMPNodeUtils.AppendLangItem(arrayNode, specificLang, itemValue);
if (specificXDefault)
{
haveXDefault = true;
}
break;
}
case XMPNodeUtils.CLT_XDEFAULT:
{
// Create the specific language, update x-default if it was the only
// item.
if (xdItem != null && arrayNode.GetChildrenLength() == 1)
{
xdItem.SetValue(itemValue);
}
XMPNodeUtils.AppendLangItem(arrayNode, specificLang, itemValue);
break;
}
case XMPNodeUtils.CLT_FIRST_ITEM:
{
// Create the specific language, don't add an x-default item.
XMPNodeUtils.AppendLangItem(arrayNode, specificLang, itemValue);
if (specificXDefault)
{
haveXDefault = true;
}
break;
}
default:
{
// does not happen under normal circumstances
throw new XMPException("Unexpected result from ChooseLocalizedText", XMPError.INTERNALFAILURE
);
}
}
// Add an x-default at the front if needed.
if (!haveXDefault && arrayNode.GetChildrenLength() == 1)
{
XMPNodeUtils.AppendLangItem(arrayNode, XMPConst.X_DEFAULT, itemValue);
}
}