/// <exception cref="XmlException">XML is not well-formed.</exception>
        internal override sealed bool OptionPropCallback(PrintCapabilityOption baseOption, XmlPrintCapReader reader)
        {
            NUpOption option  = baseOption as NUpOption;
            bool      handled = false;

            // we are only handling scored property here
            if (reader.CurrentElementNodeType == PrintSchemaNodeTypes.ScoredProperty)
            {
                if (reader.CurrentElementNameAttrValue == PrintSchemaTags.Keywords.NUpKeys.PagesPerSheet)
                {
                    try
                    {
                        option._pagesPerSheet = 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
                    }

                    handled = true;
                }
            }

            return(handled);
        }
        /// <exception cref="XmlException">XML parser finds non-well-formness of XML</exception>
        internal override sealed bool BuildProperty(XmlPrintCapReader reader)
        {
            #if _DEBUG
            Trace.Assert(reader.CurrentElementNodeType == PrintSchemaNodeTypes.Property,
                         "THIS SHOULD NOT HAPPEN: RootPropertyPropCallback gets non-Property node");
            #endif

            int subPropDepth = reader.CurrentElementDepth + 1;

            // Loops over immediate property children of the root-level property
            while (reader.MoveToNextSchemaElement(subPropDepth,
                                                  PrintSchemaNodeTypes.Property))
            {
                if (reader.CurrentElementNameAttrValue == PrintSchemaTags.Keywords.PageImageableSizeKeys.ImageableSizeWidth)
                {
                    try
                    {
                        this._imageableSizeWidth = 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.PageImageableSizeKeys.ImageableSizeHeight)
                {
                    try
                    {
                        this._imageableSizeHeight = 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.PageImageableSizeKeys.ImageableArea)
                {
                    this._imageableArea = new CanvasImageableArea(this);

                    // When need to loop at a deeper depth, the code should cache the desired depth
                    // value and use the cached value in the while-loop. Using CurrentElementDepth
                    // in while-loop won't work correctly since the CurrentElementDepth value is changing.
                    int iaPropDepth = reader.CurrentElementDepth + 1;

                    // loop over one level down to read "ImageableArea" child-element properties
                    while (reader.MoveToNextSchemaElement(iaPropDepth,
                                                          PrintSchemaNodeTypes.Property))
                    {
                        if (reader.CurrentElementNameAttrValue == PrintSchemaTags.Keywords.PageImageableSizeKeys.OriginWidth)
                        {
                            try
                            {
                                this._imageableArea._originWidth = 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.PageImageableSizeKeys.OriginHeight)
                        {
                            try
                            {
                                this._imageableArea._originHeight = 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.PageImageableSizeKeys.ExtentWidth)
                        {
                            try
                            {
                                this._imageableArea._extentWidth = 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.PageImageableSizeKeys.ExtentHeight)
                        {
                            try
                            {
                                this._imageableArea._extentHeight = 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 _DEBUG
                            Trace.WriteLine("-Warning- skip unknown ImageableArea sub-property '" +
                                            reader.CurrentElementNameAttrValue + "' at line " +
                                            reader._xmlReader.LineNumber + ", position " +
                                            reader._xmlReader.LinePosition);
                            #endif
                        }
                    }
                }
                else
                {
                    #if _DEBUG
                    Trace.WriteLine("-Warning- skip unknown PageImageableSize sub-Property '" +
                                    reader.CurrentElementNameAttrValue + "' at line " +
                                    reader._xmlReader.LineNumber + ", position " +
                                    reader._xmlReader.LinePosition);
                    #endif
                }
            }

            bool isValid = false;

            // We require ImageableSizeWidth/Height and ExtentWidth/Height values must be non-negative
            if ((this._imageableSizeWidth >= 0) &&
                (this._imageableSizeHeight >= 0))
            {
                isValid = true;

                // If ImageableArea is present, then its ExtentWidth/Height values must be non-negative.
                if (this.ImageableArea != null)
                {
                    isValid = false;

                    if ((this.ImageableArea._extentWidth >= 0) &&
                        (this.ImageableArea._extentHeight >= 0))
                    {
                        isValid = true;
                    }
                }
            }
            else
            {
                #if _DEBUG
                Trace.WriteLine("-Error- invalid PageImageableSize size values: " + this.ToString());
                #endif
            }

            return(isValid);
        }
        /// <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);
        }
示例#4
0
        // With current design, all parameter-def properties are generic to any specific parameters,
        // so we just need to implement the prop-callback at the base class level and all derived
        // classes will inherit the implementation.
        /// <exception cref="XmlException">XML is not well-formed.</exception>
        internal override sealed bool ParamDefPropCallback(ParameterDefinition baseParam, XmlPrintCapReader reader)
        {
            NonNegativeIntParameterDefinition param = baseParam as NonNegativeIntParameterDefinition;
            bool handled = true;

            #if _DEBUG
            Trace.Assert(reader.CurrentElementNodeType == PrintSchemaNodeTypes.Property,
                         "THIS SHOULD NOT HAPPEN: NonNegativeIntParamDefPropCallback() gets non-Property node");
            #endif

            if (reader.CurrentElementPSFNameAttrValue == PrintSchemaTags.Keywords.ParameterProps.DefaultValue)
            {
                try
                {
                    param._defaultValue = 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.CurrentElementPSFNameAttrValue == PrintSchemaTags.Keywords.ParameterProps.MaxValue)
            {
                try
                {
                    param._maxValue = 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.CurrentElementPSFNameAttrValue == PrintSchemaTags.Keywords.ParameterProps.MinValue)
            {
                try
                {
                    param._minValue = 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
            {
                handled = false;

                #if _DEBUG
                Trace.WriteLine("-Warning- skip unknown Property '" +
                                reader.CurrentElementNameAttrValue + "' at line " +
                                reader._xmlReader.LineNumber + ", position " +
                                reader._xmlReader.LinePosition);
                #endif
            }

            return(handled);
        }