internal override sealed bool AddOptionCallback(PrintCapabilityOption baseOption)
{
bool added = false;
InputBinOption option = baseOption as InputBinOption;
// Validate the option is complete before adding it to the collection
if (option._optionName != null)
{
int enumValue = PrintSchemaMapper.SchemaNameToEnumValueWithArray(
PrintSchemaTags.Keywords.InputBinKeys.InputBinNames,
PrintSchemaTags.Keywords.InputBinKeys.InputBinEnums,
option._optionName);
if (enumValue > 0)
{
// We require the InputBin option to have an option name
option._value = (InputBin)enumValue;
this.InputBins.Add(option);
added = true;
}
}
return(added);
}
internal override sealed bool AddOptionCallback(PrintCapabilityOption baseOption)
{
FixedMediaSizeOption option = baseOption as FixedMediaSizeOption;
bool complete = false;
// All PageMediaSize options must have an option name
if (option._optionName == null)
{
return(complete);
}
int enumValue = PrintSchemaMapper.SchemaNameToEnumValueWithArray(
PrintSchemaTags.Keywords.PageMediaSizeKeys.MediaSizeNames,
PrintSchemaTags.Keywords.PageMediaSizeKeys.MediaSizeEnums,
option._optionName);
// We only support standard Print Schema options
if (enumValue > 0)
{
option._value = (PageMediaSizeName)enumValue;
if ((option._mediaSizeWidth > 0) ||
(option._mediaSizeHeight > 0))
{
this.FixedMediaSizes.Add(option);
complete = true;
}
}
return(complete);
}
/// <summary>
/// Finds the array index of a standard PrintCapabilities feature
/// </summary>
/// <returns>non-negative index if matching feature found, otherwise -1</returns>
/// <exception>none</exception>
private static int LookupFeatureIndex(string featureName, bool isSubFeature)
{
// The mapper returns int-value of the feature's enum, which is what we use
// as the feature array index.
return(PrintSchemaMapper.SchemaNameToEnumValueWithMap(
isSubFeature ? PrintSchemaTags.Keywords.SubFeatureMapTable :
PrintSchemaTags.Keywords.FeatureMapTable,
featureName));
}
internal override sealed bool AddOptionCallback(PrintCapabilityOption baseOption)
{
bool added = false;
NUpPresentationDirectionOption option = baseOption as NUpPresentationDirectionOption;
// validate the option is complete before adding it to the collection
if (option._optionName != null)
{
int enumValue = PrintSchemaMapper.SchemaNameToEnumValueWithArray(
PrintSchemaTags.Keywords.NUpKeys.DirectionNames,
PrintSchemaTags.Keywords.NUpKeys.DirectionEnums,
option._optionName);
if (enumValue > 0)
{
option._value = (PagesPerSheetDirection)enumValue;
this.PresentationDirections.Add(option);
added = true;
}
}
return(added);
}
internal override sealed bool AddOptionCallback(PrintCapabilityOption baseOption)
{
bool added = false;
TrueTypeFontModeOption option = baseOption as TrueTypeFontModeOption;
// validate the option is complete before adding it to the collection
if (option._optionName != null)
{
int enumValue = PrintSchemaMapper.SchemaNameToEnumValueWithArray(
PrintSchemaTags.Keywords.PageTrueTypeFontModeKeys.ModeNames,
PrintSchemaTags.Keywords.PageTrueTypeFontModeKeys.ModeEnums,
option._optionName);
if (enumValue > 0)
{
option._value = (TrueTypeFontMode)enumValue;
this.TrueTypeFontModes.Add(option);
added = true;
}
}
return(added);
}
/// <summary>
/// Finds the array index of a standard PrintCapabilities parameter-def
/// </summary>
/// <returns>non-negative index if matching parameter-def found, otherwise -1</returns>
/// <exception>none</exception>
private static int LookupParameterIndex(string paramName, out bool isLocalParam)
{
isLocalParam = false;
int index = PrintSchemaMapper.SchemaNameToEnumValueWithMap(
PrintSchemaTags.Keywords.GlobalParameterMapTable,
paramName);
if (index < 0)
{
// We didn't find a match to a global parameter. Now try the local parameters.
index = PrintSchemaMapper.SchemaNameToEnumValueWithMap(
PrintSchemaTags.Keywords.LocalParameterMapTable,
paramName);
// If a match is found, we know it must be a local param
if (index >= 0)
{
isLocalParam = true;
}
}
return(index);
}
/// <summary>
/// Moves the reader cursor to the next Print Schema Framework element at the given depth.
/// (The element could be Feature, ParameterDefinition, Option, ScoredProperty or Property)
/// </summary>
/// <param name="depth">client-requested traversing depth</param>
/// <param name="typeFilterFlags">flags to indicate client interested node types</param>
/// <returns>True if next Framework element is ready to read.
/// False if no more Framework element at the given depth.</returns>
/// <exception cref="XmlException">XML is not well-formed.</exception>
public bool MoveToNextSchemaElement(int depth, PrintSchemaNodeTypes typeFilterFlags)
{
bool foundElement = false;
while (!foundElement && _xmlReader.Read())
{
// Read() throws XmlException if error occurred while parsing the XML.
// If we hit an end-element tag at higher depth, we know there are no more
// Framework elements at the client-requested depth.
if ((_xmlReader.NodeType == XmlNodeType.EndElement) &&
(_xmlReader.Depth < depth))
{
break;
}
// Stop at the next XML start element at the client-requested depth
// and in the standard Framework element namespace.
if ((_xmlReader.NodeType != XmlNodeType.Element) ||
(_xmlReader.Depth != depth) ||
(_xmlReader.NamespaceURI != PrintSchemaNamespaces.Framework))
{
continue;
}
// Find a candidate, so reset internal states to be ready for its parsing.
ResetCurrentElementState();
foundElement = true;
_currentElementDepth = depth;
_currentElementIsEmpty = _xmlReader.IsEmptyElement;
// Map element name to Schema node type
int enumValue = PrintSchemaMapper.SchemaNameToEnumValueWithMap(
PrintSchemaTags.Framework.NodeTypeMapTable,
_xmlReader.LocalName);
if (enumValue > 0)
{
_currentElementNodeType = (PrintSchemaNodeTypes)enumValue;
}
else
{
#if _DEBUG
Trace.WriteLine("-Warning- skip unknown element '" + _xmlReader.LocalName +
"' at line " + _xmlReader.LineNumber + ", position " +
_xmlReader.LinePosition);
#endif
foundElement = false;
}
if (foundElement)
{
// Check whether or not the found element type is what client is interested in.
// If not, we will skip this element.
if ((CurrentElementNodeType & typeFilterFlags) == 0)
{
#if _DEBUG
Trace.WriteLine("-Warning- skip not-wanted element '" + _xmlReader.LocalName +
"' at line " + _xmlReader.LineNumber + ", position " +
_xmlReader.LinePosition);
#endif
foundElement = false;
}
}
if (foundElement)
{
// The element is what the client wants.
if (CurrentElementNodeType != PrintSchemaNodeTypes.Value)
{
// Element other than <Value> should have the "name" XML attribute.
// Reader will verify the "name" XML attribute has a QName value that
// is in our standard Keyword namespace.
string QName = _xmlReader.GetAttribute(PrintSchemaTags.Framework.NameAttr,
PrintSchemaNamespaces.FrameworkAttrForXmlReader);
// Only <Option> element is allowed not to have the "name" XML attribute
if (QName == null)
{
if (CurrentElementNodeType != PrintSchemaNodeTypes.Option)
{
#if _DEBUG
Trace.WriteLine("-Warning- skip element " + CurrentElementNodeType +
" at line " + _xmlReader.LineNumber + ", position " +
_xmlReader.LinePosition + " due to missing 'name' XML attribute");
#endif
foundElement = false;
}
}
else
{
string URI = XmlReaderQName.GetURI(_xmlReader, QName);
string localName = XmlReaderQName.GetLocalName(QName);
if (URI == PrintSchemaNamespaces.Framework)
{
_currentElementPSFNameAttrValue = localName;
}
else if (URI == PrintSchemaNamespaces.StandardKeywordSet)
{
_currentElementNameAttrValue = localName;
}
else
{
// If QName value is not in standard PSF or PSK namespace,
// then skip this Schema element.
#if _DEBUG
Trace.WriteLine("-Warning- skip element " + CurrentElementNodeType +
" at line " + _xmlReader.LineNumber + ", position " +
_xmlReader.LinePosition +
" due to non-PSF/PSK 'name' XML attribute value: " + QName);
#endif
foundElement = false;
}
}
}
else
{
// For <Value> element, we need to get its element text value.
// If this function tells client the <Value> element is found, it guarantees
// that the <Value> element text value is non-empty.
// Needs to handle xsi:type verification
// ReadElementString() returns empty string if the element is empty
// (<item></item> or <item/>), and it could throws XmlException.
_currentElementTextValue = _xmlReader.ReadElementString();
// Our schema requires that <Value> element should always have non-empty value.
if ((_currentElementTextValue == null) || (_currentElementTextValue.Length == 0))
{
#if _DEBUG
Trace.WriteLine("-Warning- skip element " + CurrentElementNodeType +
" at line " + _xmlReader.LineNumber + ", position " +
_xmlReader.LinePosition + " since it has empty element text");
#endif
_currentElementTextValue = null;
foundElement = false;
}
}
}
}
return(foundElement);
}
internal override sealed bool AddOptionCallback(PrintCapabilityOption baseOption)
{
bool complete = false;
ScalingOption option = baseOption as ScalingOption;
if (option._optionName != null)
{
int enumValue = PrintSchemaMapper.SchemaNameToEnumValueWithArray(
PrintSchemaTags.Keywords.PageScalingKeys.ScalingNames,
PrintSchemaTags.Keywords.PageScalingKeys.ScalingEnums,
option._optionName);
if (enumValue > 0)
{
option._value = (PageScaling)enumValue;
}
}
if (option.Value != PageScaling.Unspecified)
{
if (option.Value == PageScaling.None)
{
// Non-custom scaling option doesn't need any ParameterRefs
complete = true;
}
else if (option.Value == PageScaling.Custom)
{
// Custom scaling option must have the 2 scale ParameterRefs
if ((option._scaleWIndex >= 0) &&
(option._scaleHIndex >= 0))
{
complete = true;
}
else
{
// Need to reset the local parameter required flag since we are
// ignoring the custom scaling option
if (option._scaleWIndex >= 0)
{
option.OwnerFeature.OwnerPrintCap.SetLocalParameterDefAsRequired(option._scaleWIndex, false);
}
if (option._scaleHIndex >= 0)
{
option.OwnerFeature.OwnerPrintCap.SetLocalParameterDefAsRequired(option._scaleHIndex, false);
}
}
}
else if (option.Value == PageScaling.CustomSquare)
{
// Custom square scaling option must have the scale ParameterRef
if (option._squareScaleIndex >= 0)
{
complete = true;
}
else
{
// Need to reset the local parameter required flag since we are
// ignoring the custom scaling option
if (option._squareScaleIndex >= 0)
{
option.OwnerFeature.OwnerPrintCap.SetLocalParameterDefAsRequired(option._squareScaleIndex, false);
}
}
}
}
if (complete)
{
this.ScalingOptions.Add(option);
}
return(complete);
}
/// <exception cref="XmlException">XML is not well-formed.</exception>
internal override sealed bool OptionPropCallback(PrintCapabilityOption baseOption, XmlPrintCapReader reader)
{
ResolutionOption option = baseOption as ResolutionOption;
bool handled = false;
if (reader.CurrentElementNodeType == PrintSchemaNodeTypes.ScoredProperty)
{
handled = true;
if (reader.CurrentElementNameAttrValue == PrintSchemaTags.Keywords.PageResolutionKeys.ResolutionX)
{
try
{
option._resolutionX = reader.GetCurrentPropertyIntValueWithException();
}
// We want to catch internal FormatException to skip recoverable XML content syntax error
#pragma warning suppress 56502
#if _DEBUG
catch (FormatException e)
#else
catch (FormatException)
#endif
{
#if _DEBUG
Trace.WriteLine("-Error- " + e.Message);
#endif
}
}
else if (reader.CurrentElementNameAttrValue == PrintSchemaTags.Keywords.PageResolutionKeys.ResolutionY)
{
try
{
option._resolutionY = reader.GetCurrentPropertyIntValueWithException();
}
// We want to catch internal FormatException to skip recoverable XML content syntax error
#pragma warning suppress 56502
#if _DEBUG
catch (FormatException e)
#else
catch (FormatException)
#endif
{
#if _DEBUG
Trace.WriteLine("-Error- " + e.Message);
#endif
}
}
else if (reader.CurrentElementNameAttrValue == PrintSchemaTags.Keywords.PageResolutionKeys.QualitativeResolution)
{
int enumValue;
if (PrintSchemaMapper.CurrentPropertyQValueToEnumValue(reader,
PrintSchemaTags.Keywords.PageResolutionKeys.QualityNames,
PrintSchemaTags.Keywords.PageResolutionKeys.QualityEnums,
out enumValue))
{
option._qualityValue = (PageQualitativeResolution)enumValue;
}
}
else
{
handled = false;
#if _DEBUG
Trace.WriteLine("-Warning- skip unknown ScoredProperty '" +
reader.CurrentElementNameAttrValue + "' at line " +
reader._xmlReader.LineNumber + ", position " +
reader._xmlReader.LinePosition);
#endif
}
}
return(handled);
}
