/// <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);
}
/// <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>Deletes the the given node and its children from its parent.</summary>
/// <remarks>
/// Deletes the the given node and its children from its parent.
/// Takes care about adjusting the flags.
/// </remarks>
/// <param name="node">the top-most node to delete.</param>
internal static void DeleteNode(XMPNode node)
{
XMPNode parent = node.GetParent();
if (node.GetOptions().IsQualifier())
{
// root is qualifier
parent.RemoveQualifier(node);
}
else
{
// root is NO qualifier
parent.RemoveChild(node);
}
// delete empty Schema nodes
if (!parent.HasChildren() && parent.GetOptions().IsSchemaNode())
{
parent.GetParent().RemoveChild(parent);
}
}
/// <summary>See if an array is an alt-text array.</summary>
/// <remarks>
/// See if an array is an alt-text array. If so, make sure the x-default item
/// is first.
/// </remarks>
/// <param name="arrayNode">the array node to check if its an alt-text array</param>
internal static void DetectAltText(XMPNode arrayNode)
{
if (arrayNode.GetOptions().IsArrayAlternate() && arrayNode.HasChildren())
{
bool isAltText = false;
for (IEnumerator it = arrayNode.IterateChildren(); it.MoveNext();)
{
XMPNode child = (XMPNode)it.Current;
if (child.GetOptions().GetHasLanguage())
{
isAltText = true;
break;
}
}
if (isAltText)
{
arrayNode.GetOptions().SetArrayAltText(true);
NormalizeLangArray(arrayNode);
}
}
}
/// <summary>
/// <ol>
/// <li>Look for an exact match with the specific language.
/// </summary>
/// <remarks>
/// <ol>
/// <li>Look for an exact match with the specific language.
/// <li>If a generic language is given, look for partial matches.
/// <li>Look for an "x-default"-item.
/// <li>Choose the first item.
/// </ol>
/// </remarks>
/// <param name="arrayNode">the alt text array node</param>
/// <param name="genericLang">the generic language</param>
/// <param name="specificLang">the specific language</param>
/// <returns>
/// Returns the kind of match as an Integer and the found node in an
/// array.
/// </returns>
/// <exception cref="iText.Kernel.XMP.XMPException"/>
internal static Object[] ChooseLocalizedText(XMPNode arrayNode, String genericLang
, String specificLang)
{
// See if the array has the right form. Allow empty alt arrays,
// that is what parsing returns.
if (!arrayNode.GetOptions().IsArrayAltText())
{
throw new XMPException("Localized text array is not alt-text", XMPError.BADXPATH);
}
else
{
if (!arrayNode.HasChildren())
{
return(new Object[] { XMPNodeUtils.CLT_NO_VALUES, null });
}
}
int foundGenericMatches = 0;
XMPNode resultNode = null;
XMPNode xDefault = null;
// Look for the first partial match with the generic language.
for (IEnumerator it = arrayNode.IterateChildren(); it.MoveNext();)
{
XMPNode currItem = (XMPNode)it.Current;
// perform some checks on the current item
if (currItem.GetOptions().IsCompositeProperty())
{
throw new XMPException("Alt-text array item is not simple", XMPError.BADXPATH);
}
else
{
if (!currItem.HasQualifier() || !XML_LANG.Equals(currItem.GetQualifier(1).GetName
()))
{
throw new XMPException("Alt-text array item has no language qualifier", XMPError.
BADXPATH);
}
}
String currLang = currItem.GetQualifier(1).GetValue();
// Look for an exact match with the specific language.
if (specificLang.Equals(currLang))
{
return(new Object[] { XMPNodeUtils.CLT_SPECIFIC_MATCH, currItem });
}
else
{
if (genericLang != null && currLang.StartsWith(genericLang))
{
if (resultNode == null)
{
resultNode = currItem;
}
// ! Don't return/break, need to look for other matches.
foundGenericMatches++;
}
else
{
if (X_DEFAULT.Equals(currLang))
{
xDefault = currItem;
}
}
}
}
// evaluate loop
if (foundGenericMatches == 1)
{
return(new Object[] { XMPNodeUtils.CLT_SINGLE_GENERIC, resultNode });
}
else
{
if (foundGenericMatches > 1)
{
return(new Object[] { XMPNodeUtils.CLT_MULTIPLE_GENERIC, resultNode });
}
else
{
if (xDefault != null)
{
return(new Object[] { XMPNodeUtils.CLT_XDEFAULT, xDefault });
}
else
{
// Everything failed, choose the first item.
return(new Object[] { XMPNodeUtils.CLT_FIRST_ITEM, arrayNode.GetChild(1) });
}
}
}
}
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);
}
}
