public virtual XMPProperty GetLocalizedText(String schemaNS, String altTextName,
String genericLang, String specificLang)
{
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);
XMPNode arrayNode = XMPNodeUtils.FindNode(tree, arrayPath, false, null);
if (arrayNode == null)
{
return null;
}
Object[] result = XMPNodeUtils.ChooseLocalizedText(arrayNode, genericLang, specificLang
);
int match = (int)result[0];
XMPNode itemNode = (XMPNode)result[1];
if (match != XMPNodeUtils.CLT_NO_VALUES)
{
return new _XMPProperty_428(itemNode);
}
else
{
return null;
}
}
/// <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>Constructor with optionsl initial values.</summary>
/// <remarks>
/// Constructor with optionsl initial values. If <code>propName</code> is provided,
/// <code>schemaNS</code> has also be provided.
/// </remarks>
/// <param name="xmp">the iterated metadata object.</param>
/// <param name="schemaNS">the iteration is reduced to this schema (optional)</param>
/// <param name="propPath">the iteration is redurce to this property within the <code>schemaNS</code>
/// </param>
/// <param name="options">
/// advanced iteration options, see
/// <see cref="iText.Kernel.XMP.Options.IteratorOptions"/>
/// </param>
/// <exception cref="iText.Kernel.XMP.XMPException">If the node defined by the paramters is not existing.
/// </exception>
public XMPIteratorImpl(XMPMetaImpl xmp, String schemaNS, String propPath, IteratorOptions
options)
{
// make sure that options is defined at least with defaults
this.options = options ?? new IteratorOptions();
// the start node of the iteration depending on the schema and property filter
XMPNode startNode;
string initialPath = null;
bool baseSchema = !String.IsNullOrEmpty(schemaNS);
bool baseProperty = !String.IsNullOrEmpty(propPath);
if (!baseSchema && !baseProperty)
{
// complete tree will be iterated
startNode = xmp.GetRoot();
}
else if (baseSchema && baseProperty)
{
// Schema and property node provided
XMPPath path = XMPPathParser.ExpandXPath(schemaNS, propPath);
// base path is the prop path without the property leaf
XMPPath basePath = new XMPPath();
for (int i = 0; i < path.Size() - 1; i++)
{
basePath.Add(path.GetSegment(i));
}
startNode = XMPNodeUtils.FindNode(xmp.GetRoot(), path, false, null);
this.baseNS = schemaNS;
initialPath = basePath.ToString();
}
else if (baseSchema && !baseProperty)
{
// Only Schema provided
startNode = XMPNodeUtils.FindSchemaNode(xmp.GetRoot(), schemaNS, false);
}
else // !baseSchema && baseProperty
{
// No schema but property provided -> error
throw new XMPException("Schema namespace URI is required", XMPError.BADSCHEMA);
}
// create iterator
if (startNode != null)
{
this.nodeIterator = (!this.options.IsJustChildren())
? new NodeIterator(this, startNode, initialPath, 1)
: new NodeIteratorChildren(this, startNode, initialPath);
}
else
{
// create null iterator
this.nodeIterator = EmptyList.GetEnumerator();
}
}
public virtual void AppendArrayItem(String schemaNS, String arrayName, PropertyOptions
arrayOptions, String itemValue, PropertyOptions itemOptions)
{
ParameterAsserts.AssertSchemaNS(schemaNS);
ParameterAsserts.AssertArrayName(arrayName);
if (arrayOptions == null)
{
arrayOptions = new PropertyOptions();
}
if (!arrayOptions.IsOnlyArrayOptions())
{
throw new XMPException("Only array form flags allowed for arrayOptions", XMPError
.BADOPTIONS);
}
// Check if array options are set correctly.
arrayOptions = XMPNodeUtils.VerifySetOptions(arrayOptions, null);
// Locate or create the array. If it already exists, make sure the array
// form from the options
// parameter is compatible with the current state.
XMPPath arrayPath = XMPPathParser.ExpandXPath(schemaNS, arrayName);
// Just lookup, don't try to create.
XMPNode arrayNode = XMPNodeUtils.FindNode(tree, arrayPath, false, null);
if (arrayNode != null)
{
// The array exists, make sure the form is compatible. Zero
// arrayForm means take what exists.
if (!arrayNode.GetOptions().IsArray())
{
throw new XMPException("The named property is not an array", XMPError.BADXPATH);
}
}
else
{
// if (arrayOptions != null && !arrayOptions.equalArrayTypes(arrayNode.getOptions()))
// {
// throw new XMPException("Mismatch of existing and specified array form", BADOPTIONS);
// }
// The array does not exist, try to create it.
if (arrayOptions.IsArray())
{
arrayNode = XMPNodeUtils.FindNode(tree, arrayPath, true, arrayOptions);
if (arrayNode == null)
{
throw new XMPException("Failure creating array node", XMPError.BADXPATH);
}
}
else
{
// array options missing
throw new XMPException("Explicit arrayOptions required to create new array", XMPError
.BADOPTIONS);
}
}
DoSetArrayItem(arrayNode, ARRAY_LAST_ITEM, itemValue, itemOptions, true);
}
public virtual bool DoesPropertyExist(String schemaNS, String propName)
{
try
{
ParameterAsserts.AssertSchemaNS(schemaNS);
ParameterAsserts.AssertPropName(propName);
XMPPath expPath = XMPPathParser.ExpandXPath(schemaNS, propName);
XMPNode propNode = XMPNodeUtils.FindNode(tree, expPath, false, null);
return propNode != null;
}
catch (XMPException)
{
return false;
}
}
public virtual void SetProperty(String schemaNS, String propName, Object propValue
, PropertyOptions options)
{
ParameterAsserts.AssertSchemaNS(schemaNS);
ParameterAsserts.AssertPropName(propName);
options = XMPNodeUtils.VerifySetOptions(options, propValue);
XMPPath expPath = XMPPathParser.ExpandXPath(schemaNS, propName);
XMPNode propNode = XMPNodeUtils.FindNode(tree, expPath, true, options);
if (propNode != null)
{
SetNode(propNode, propValue, options, false);
}
else
{
throw new XMPException("Specified property does not exist", XMPError.BADXPATH);
}
}
public virtual void InsertArrayItem(String schemaNS, String arrayName, int itemIndex
, String itemValue, PropertyOptions options)
{
ParameterAsserts.AssertSchemaNS(schemaNS);
ParameterAsserts.AssertArrayName(arrayName);
// Just lookup, don't try to create.
XMPPath arrayPath = XMPPathParser.ExpandXPath(schemaNS, arrayName);
XMPNode arrayNode = XMPNodeUtils.FindNode(tree, arrayPath, false, null);
if (arrayNode != null)
{
DoSetArrayItem(arrayNode, itemIndex, itemValue, options, true);
}
else
{
throw new XMPException("Specified array does not exist", XMPError.BADXPATH);
}
}
public virtual void DeleteProperty(String schemaNS, String propName)
{
try
{
ParameterAsserts.AssertSchemaNS(schemaNS);
ParameterAsserts.AssertPropName(propName);
XMPPath expPath = XMPPathParser.ExpandXPath(schemaNS, propName);
XMPNode propNode = XMPNodeUtils.FindNode(tree, expPath, false, null);
if (propNode != null)
{
XMPNodeUtils.DeleteNode(propNode);
}
}
catch (XMPException)
{
// EMPTY, exceptions are ignored within delete
}
}
public virtual int CountArrayItems(String schemaNS, String arrayName)
{
ParameterAsserts.AssertSchemaNS(schemaNS);
ParameterAsserts.AssertArrayName(arrayName);
XMPPath arrayPath = XMPPathParser.ExpandXPath(schemaNS, arrayName);
XMPNode arrayNode = XMPNodeUtils.FindNode(tree, arrayPath, false, null);
if (arrayNode == null)
{
return 0;
}
if (arrayNode.GetOptions().IsArray())
{
return arrayNode.GetChildrenLength();
}
else
{
throw new XMPException("The named property is not an array", XMPError.BADXPATH);
}
}
/// <summary>Returns a property, but the result value can be requested.</summary>
/// <seealso cref="iText.Kernel.XMP.XMPMeta.GetProperty(System.String, System.String)
/// "/>
/// <param name="schemaNS">a schema namespace</param>
/// <param name="propName">a property name or path</param>
/// <param name="valueType">the type of the value, see VALUE_...</param>
/// <returns>
/// Returns the node value as an object according to the
/// <code>valueType</code>.
/// </returns>
/// <exception cref="iText.Kernel.XMP.XMPException">Collects any exception that occurs.</exception>
protected internal virtual Object GetPropertyObject(String schemaNS, String propName
, int valueType)
{
ParameterAsserts.AssertSchemaNS(schemaNS);
ParameterAsserts.AssertPropName(propName);
XMPPath expPath = XMPPathParser.ExpandXPath(schemaNS, propName);
XMPNode propNode = XMPNodeUtils.FindNode(tree, expPath, false, null);
if (propNode != null)
{
if (valueType != VALUE_STRING && propNode.GetOptions().IsCompositeProperty())
{
throw new XMPException("Property must be simple when a value type is requested",
XMPError.BADXPATH);
}
return EvaluateNodeValue(valueType, propNode);
}
else
{
return null;
}
}
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);
}
}
