| static private IsInternalProperty ( string schema, string prop ) : bool | ||
| schema | string | /// a schema namespace |
| prop | string | /// an XMP Property |
| return | bool | |
/// <seealso cref= XMPUtils#appendProperties(XMPMeta, XMPMeta, boolean, boolean) </seealso>
/// <param name="source"> The source XMP object. </param>
/// <param name="destination"> The destination XMP object. </param>
/// <param name="doAllProperties"> Do internal properties in addition to external properties. </param>
/// <param name="replaceOldValues"> Replace the values of existing properties. </param>
/// <param name="deleteEmptyValues"> Delete destination values if source property is empty. </param>
/// <exception cref="XmpException"> Forwards the Exceptions from the metadata processing </exception>
public static void AppendProperties(IXmpMeta source, IXmpMeta destination, bool doAllProperties,
bool replaceOldValues, bool deleteEmptyValues)
{
ParameterAsserts.AssertImplementation(source);
ParameterAsserts.AssertImplementation(destination);
XmpMetaImpl src = (XmpMetaImpl)source;
XmpMetaImpl dest = (XmpMetaImpl)destination;
for (IEnumerator it = src.Root.IterateChildren(); it.MoveNext();)
{
XmpNode sourceSchema = (XmpNode)it.Current;
if (sourceSchema == null)
{
continue;
}
// Make sure we have a destination schema node
XmpNode destSchema = XmpNodeUtils.FindSchemaNode(dest.Root, sourceSchema.Name, false);
bool createdSchema = false;
if (destSchema == null)
{
PropertyOptions propertyOptions = new PropertyOptions();
propertyOptions.SchemaNode = true;
destSchema = new XmpNode(sourceSchema.Name, sourceSchema.Value,
propertyOptions);
dest.Root.AddChild(destSchema);
createdSchema = true;
}
// Process the source schema's children.
for (IEnumerator ic = sourceSchema.IterateChildren(); ic.MoveNext();)
{
XmpNode sourceProp = (XmpNode)ic.Current;
if (sourceProp == null)
{
continue;
}
if (doAllProperties || !Utils.IsInternalProperty(sourceSchema.Name, sourceProp.Name))
{
AppendSubtree(dest, sourceProp, destSchema, replaceOldValues, deleteEmptyValues);
}
}
if (!destSchema.HasChildren() && (createdSchema || deleteEmptyValues))
{
// Don't create an empty schema / remove empty schema.
dest.Root.RemoveChild(destSchema);
}
}
}
/// <summary>
/// Remove all schema children according to the flag
/// <code>doAllProperties</code>. Empty schemas are automatically remove
/// by <code>XMPNode</code>
/// </summary>
/// <param name="schemaNode">
/// a schema node </param>
/// <param name="doAllProperties">
/// flag if all properties or only externals shall be removed. </param>
/// <returns> Returns true if the schema is empty after the operation. </returns>
private static bool RemoveSchemaChildren(XmpNode schemaNode, bool doAllProperties)
{
ArrayList currPropsToRemove = new ArrayList();
for (IEnumerator it = schemaNode.IterateChildren(); it.MoveNext();)
{
XmpNode currProp = (XmpNode)it.Current;
if (currProp == null)
{
continue;
}
if (doAllProperties || !Utils.IsInternalProperty(schemaNode.Name, currProp.Name))
{
currPropsToRemove.Add(currProp);
}
}
foreach (XmpNode xmpNode in currPropsToRemove)
{
schemaNode.Children.Remove(xmpNode);
}
currPropsToRemove.Clear();
return(!schemaNode.HasChildren());
}
/// <seealso cref= XMPUtils#removeProperties(XMPMeta, String, String, boolean, boolean)
/// </seealso>
/// <param name="xmp">
/// The XMP object containing the properties to be removed.
/// </param>
/// <param name="schemaNs">
/// Optional schema namespace URI for the properties to be
/// removed.
/// </param>
/// <param name="propName">
/// Optional path expression for the property to be removed.
/// </param>
/// <param name="doAllProperties">
/// Option flag to control the deletion: do internal properties in
/// addition to external properties. </param>
/// <param name="includeAliases">
/// Option flag to control the deletion: Include aliases in the
/// "named schema" case above. </param>
/// <exception cref="XmpException"> If metadata processing fails </exception>
public static void RemoveProperties(IXmpMeta xmp, string schemaNs, string propName, bool doAllProperties,
bool includeAliases)
{
ParameterAsserts.AssertImplementation(xmp);
XmpMetaImpl xmpImpl = (XmpMetaImpl)xmp;
if (!string.IsNullOrEmpty(propName))
{
// Remove just the one indicated property. This might be an alias,
// the named schema might not actually exist. So don't lookup the
// schema node.
if (string.IsNullOrEmpty(schemaNs))
{
throw new XmpException("Property name requires schema namespace", XmpError.BADPARAM);
}
XmpPath expPath = XmpPathParser.ExpandXPath(schemaNs, propName);
XmpNode propNode = XmpNodeUtils.FindNode(xmpImpl.Root, expPath, false, null);
if (propNode != null)
{
if (doAllProperties ||
!Utils.IsInternalProperty(expPath.GetSegment((int)XmpPath.STEP_SCHEMA).Name,
expPath.GetSegment((int)XmpPath.STEP_ROOT_PROP).Name))
{
XmpNode parent = propNode.Parent;
parent.RemoveChild(propNode);
if (parent.Options.SchemaNode && !parent.HasChildren())
{
// remove empty schema node
parent.Parent.RemoveChild(parent);
}
}
}
}
else if (!string.IsNullOrEmpty(schemaNs))
{
// Remove all properties from the named schema. Optionally include
// aliases, in which case
// there might not be an actual schema node.
// XMP_NodePtrPos schemaPos;
XmpNode schemaNode = XmpNodeUtils.FindSchemaNode(xmpImpl.Root, schemaNs, false);
if (schemaNode != null)
{
if (RemoveSchemaChildren(schemaNode, doAllProperties))
{
xmpImpl.Root.RemoveChild(schemaNode);
}
}
if (includeAliases)
{
// We're removing the aliases also. Look them up by their
// namespace prefix.
// But that takes more code and the extra speed isn't worth it.
// Lookup the XMP node
// from the alias, to make sure the actual exists.
IXmpAliasInfo[] aliases = XmpMetaFactory.SchemaRegistry.FindAliases(schemaNs);
for (int i = 0; i < aliases.Length; i++)
{
IXmpAliasInfo info = aliases[i];
XmpPath path = XmpPathParser.ExpandXPath(info.Namespace, info.PropName);
XmpNode actualProp = XmpNodeUtils.FindNode(xmpImpl.Root, path, false, null);
if (actualProp != null)
{
XmpNode parent = actualProp.Parent;
parent.RemoveChild(actualProp);
}
}
}
}
else
{
// Remove all appropriate properties from all schema. In this case
// we don't have to be
// concerned with aliases, they are handled implicitly from the
// actual properties.
ArrayList schemasToRemove = new ArrayList();
for (IEnumerator it = xmpImpl.Root.IterateChildren(); it.MoveNext();)
{
XmpNode schema = (XmpNode)it.Current;
if (schema == null)
{
continue;
}
if (RemoveSchemaChildren(schema, doAllProperties))
{
schemasToRemove.Add(schema);
}
}
foreach (XmpNode xmpNode in schemasToRemove)
{
xmpImpl.Root.Children.Remove(xmpNode);
}
schemasToRemove.Clear();
}
}