// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
 
/*++
 
 
Abstract:
 
    Definition and implementation of simple public PT/PC classes.
 
 
 
--*/
 
using System.IO;
using System.Collections.ObjectModel;
using System.Globalization;
using MS.Internal.Printing.Configuration;
 
namespace System.Printing
{
    /// <summary>
    /// Represents page imageable area capability.
    /// </summary>
    public sealed class PageImageableArea
    {
        #region Constructors
 
        internal PageImageableArea(double originW, double originH, double extentW, double extentH)
        {
            _originW = originW;
            _originH = originH;
            _extentW = extentW;
            _extentH = extentH;
        }
 
        #endregion Constructors
 
        #region Public Properties
 
        /// <summary>
        /// Gets the horizontal origin (in 1/96 inch unit) of the imageable area relative to the application media size.
        /// </summary>
        public double OriginWidth
        {
            get
            {
                return _originW;
            }
        }
 
        /// <summary>
        /// Gets the vertical origin (in 1/96 inch unit) of the imageable area relative to the application media size.
        /// </summary>
        public double OriginHeight
        {
            get
            {
                return _originH;
            }
        }
 
        /// <summary>
        /// Gets the horizontal distance (in 1/96 inch unit) between the origin and the bounding limit
        /// of the application media size.
        /// </summary>
        public double ExtentWidth
        {
            get
            {
                return _extentW;
            }
        }
 
        /// <summary>
        /// Gets the vertical distance (in 1/96 inch unit) between the origin and the bounding limit
        /// of the application media size.
        /// </summary>
        public double ExtentHeight
        {
            get
            {
                return _extentH;
            }
        }
 
        #endregion Public Properties
 
        #region Public Methods
 
        /// <summary>
        /// Converts the page imageable area capability to human-readable string.
        /// </summary>
        /// <returns>String that shows the page imageable area capability.</returns>
        public override string ToString()
        {
            return String.Format(CultureInfo.CurrentCulture, "({0}, {1}), ({2}, {3})",
                                 OriginWidth, OriginHeight, ExtentWidth, ExtentHeight);
        }
 
        #endregion Public Methods
 
        #region Private Fields
 
        private double _originW;
        private double _originH;
        private double _extentW;
        private double _extentH;
 
        #endregion private Fields
    }
 
    /// <summary>
    /// Represents supported range for page scaling factor setting.
    /// </summary>
    public sealed class PageScalingFactorRange
    {
        #region Constructors
 
        internal PageScalingFactorRange(int scaleMin, int scaleMax)
        {
            _scaleMin = scaleMin;
            _scaleMax = scaleMax;
        }
 
        #endregion Constructors
 
        #region Public Properties
 
        /// <summary>
        /// Gets the minimum page scaling factor (in percentage unit) supported.
        /// </summary>
        public int MinimumScale
        {
            get
            {
                return _scaleMin;
            }
        }
 
        /// <summary>
        /// Gets the maximum page scaling factor (in percentage unit) supported.
        /// </summary>
        public int MaximumScale
        {
            get
            {
                return _scaleMax;
            }
        }
 
        #endregion Public Properties
 
        #region Public Methods
 
        /// <summary>
        /// Converts the page scaling factor range to human-readable string.
        /// </summary>
        /// <returns>String that shows the page scaling factor range.</returns>
        public override string ToString()
        {
            return String.Format(CultureInfo.CurrentCulture, "({0}, {1})",
                                 MinimumScale, MaximumScale);
        }
 
        #endregion Public Methods
 
        #region Private Fields
 
        private int _scaleMin;
        private int _scaleMax;
 
        #endregion private Fields
    }
 
    /// <summary>
    /// Represents a printer's printing capabilities.
    /// </summary>
    public sealed class PrintCapabilities
    {
        #region Constructors
 
        /// <summary>
        /// Constructs a new instance of <see cref="PrintCapabilities"/> with printing capabilities
        /// based on the XML form of PrintCapabilities.
        /// </summary>
        /// <param name="xmlStream"><see cref="Stream"/> object containing the XML form of PrintCapabilities.</param>
        /// <exception cref="ArgumentNullException">
        /// The <paramref name="xmlStream"/> parameter is null.
        /// </exception>
        /// <exception cref="FormatException">
        /// The <see cref="Stream"/> object specified by <paramref name="xmlStream"/> parameter doesn't contain a
        /// well-formed XML PrintCapabilities. The exception object's <see cref="Exception.Message"/> property describes
        /// why the XML is not well-formed PrintCapabilities. If not null, the exception object's
        /// <see cref="Exception.InnerException"/> property provides more details.
        /// </exception>
        public PrintCapabilities(Stream xmlStream)
        {
            _printCap = new InternalPrintCapabilities(xmlStream);
        }
 
        #endregion Constructors
 
        #region Public Properties
 
        /// <summary>
        /// Gets a read-only collection of <see cref="Collation"/> that represents the printer's document collate capability.
        /// </summary>
        /// <remarks>
        /// If the printer has no document collate capability, the returned collection will be empty.
        /// </remarks>
        public ReadOnlyCollection<Collation> CollationCapability
        {
            get
            {
                if (_collationCap == null)
                {
                    List<Collation> valueSet = new List<Collation>();
 
                    if (_printCap.SupportsCapability(CapabilityName.DocumentCollate))
                    {
                        foreach (CollateOption option in _printCap.DocumentCollateCapability.CollateOptions)
                        {
                            if (!valueSet.Contains(option.Value))
                            {
                                valueSet.Add(option.Value);
                            }
                        }
                    }
 
                    _collationCap = valueSet.AsReadOnly();
                }
 
                return _collationCap;
            }
        }
 
        /// <summary>
        /// Gets a read-only collection of <see cref="DeviceFontSubstitution"/> that represents the printer's
        /// device font substitution capability.
        /// </summary>
        /// <remarks>
        /// If the printer has no device font substitution capability, the returned collection will be empty.
        /// </remarks>
        public ReadOnlyCollection<DeviceFontSubstitution> DeviceFontSubstitutionCapability
        {
            get
            {
                if (_deviceFontCap == null)
                {
                    List<DeviceFontSubstitution> valueSet = new List<DeviceFontSubstitution>();
 
                    if (_printCap.SupportsCapability(CapabilityName.PageDeviceFontSubstitution))
                    {
                        foreach (DeviceFontSubstitutionOption option in _printCap.PageDeviceFontSubstitutionCapability.DeviceFontSubstitutionOptions)
                        {
                            if (!valueSet.Contains(option.Value))
                            {
                                valueSet.Add(option.Value);
                            }
                        }
                    }
 
                    _deviceFontCap = valueSet.AsReadOnly();
 
                }
 
                return _deviceFontCap;
            }
        }
 
        /// <summary>
        /// Gets a read-only collection of <see cref="Duplexing"/> that represents the printer's job duplex capability.
        /// </summary>
        /// <remarks>
        /// If the printer has no job duplex capability, the returned collection will be empty.
        /// </remarks>
        public ReadOnlyCollection<Duplexing> DuplexingCapability
        {
            get
            {
                if (_duplexingCap == null)
                {
                    List<Duplexing> valueSet = new List<Duplexing>();
 
                    if (_printCap.SupportsCapability(CapabilityName.JobDuplex))
                    {
                        foreach (DuplexOption option in _printCap.JobDuplexCapability.DuplexOptions)
                        {
                            if (!valueSet.Contains(option.Value))
                            {
                                valueSet.Add(option.Value);
                            }
                        }
                    }
 
                    _duplexingCap = valueSet.AsReadOnly();
                }
 
                return _duplexingCap;
            }
        }
 
        /// <summary>
        /// Gets a read-only collection of <see cref="InputBin"/> that represents the printer's input bin capability.
        /// </summary>
        /// <remarks>
        /// Print Schema defines three input bin capabilities: JobInputBin, DocumentInputBin and PageInputBin.
        /// 
        /// If none of the JobInputBin, DocumentInputBin or PageInputBin capability is supported by the printer,
        /// then the returned collection will be empty. Otherwise, the returned collection will represent the printer's
        /// input bin capability for JobInputBin if JobInputBin is supported, or for DocumentInputBin if DocumentInputBin
        /// is supported, or for PageInputBin.
        /// </remarks>
        public ReadOnlyCollection<InputBin> InputBinCapability
        {
            get
            {
                if (_inputBinCap == null)
                {
                    List<InputBin> valueSet = new List<InputBin>();
 
                    Collection<InputBinOption> inputBinOptions = null;
 
                    if (_printCap.SupportsCapability(CapabilityName.JobInputBin))
                    {
                        // read the JobInputBin capability
                        inputBinOptions = _printCap.JobInputBinCapability.InputBins;
                    }
                    else if (_printCap.SupportsCapability(CapabilityName.DocumentInputBin))
                    {
                        // read the DocumentInputBin capability if JobInputBin is not supported
                        inputBinOptions = _printCap.DocumentInputBinCapability.InputBins;
                    }
                    else if (_printCap.SupportsCapability(CapabilityName.PageInputBin))
                    {
                        // read the PageInputBin capability if neither JobInputBin nor DocumentInputBin is supported
                        inputBinOptions = _printCap.PageInputBinCapability.InputBins;
                    }
 
                    if (inputBinOptions != null)
                    {
                        foreach (InputBinOption option in inputBinOptions)
                        {
                            if (!valueSet.Contains(option.Value))
                            {
                                valueSet.Add(option.Value);
                            }
                        }
                    }
 
                    _inputBinCap = valueSet.AsReadOnly();
                }
 
                return _inputBinCap;
            }
        }
 
        /// <summary>
        /// Gets the maximum job copy count the printer can support.
        /// </summary>
        /// <remarks>
        /// If the printer doesn't report maximum job copy count supported, this property will return null.
        /// </remarks>
        public Nullable<int> MaxCopyCount
        {
            get
            {
                if (_maxCopyCount == null)
                {
                    if (_printCap.SupportsCapability(CapabilityName.JobCopyCount) &&
                        (_printCap.JobCopyCountCapability.MaxValue != PrintSchema.UnspecifiedIntValue))
                    {
                        _maxCopyCount = _printCap.JobCopyCountCapability.MaxValue;
                    }
                }
 
                return _maxCopyCount;
            }
        }
 
        /// <summary>
        /// Gets the horizontal dimension (in 1/96 inch unit) of the application media size relative to the PageOrientation.
        /// </summary>
        public Nullable<double> OrientedPageMediaWidth
        {
            get
            {
                if (_orientedPageMediaWidth == null)
                {
                    if (_printCap.SupportsCapability(CapabilityName.PageImageableSize) &&
                        (_printCap.PageImageableSizeCapability.ImageableSizeWidth != PrintSchema.UnspecifiedDoubleValue))
                    {
                        _orientedPageMediaWidth = _printCap.PageImageableSizeCapability.ImageableSizeWidth;
                    }
                }
 
                return _orientedPageMediaWidth;
            }
        }
 
        /// <summary>
        /// Gets the vertical dimension (in 1/96 inch unit) of the application media size relative to the PageOrientation.
        /// </summary>
        public Nullable<double> OrientedPageMediaHeight
        {
            get
            {
                if (_orientedPageMediaHeight == null)
                {
                    if (_printCap.SupportsCapability(CapabilityName.PageImageableSize) &&
                        (_printCap.PageImageableSizeCapability.ImageableSizeHeight != PrintSchema.UnspecifiedDoubleValue))
                    {
                        _orientedPageMediaHeight = _printCap.PageImageableSizeCapability.ImageableSizeHeight;
                    }
                }
 
                return _orientedPageMediaHeight;
            }
        }
 
        /// <summary>
        /// Gets a read-only collection of <see cref="OutputColor"/> that represents the printer's
        /// page output color capability.
        /// </summary>
        /// <remarks>
        /// If the printer has no page output color capability, the returned collection will be empty.
        /// </remarks>
        public ReadOnlyCollection<OutputColor> OutputColorCapability
        {
            get
            {
                if (_outputColorCap == null)
                {
                    List<OutputColor> valueSet = new List<OutputColor>();
 
                    if (_printCap.SupportsCapability(CapabilityName.PageOutputColor))
                    {
                        foreach (OutputColorOption option in _printCap.PageOutputColorCapability.OutputColors)
                        {
                            if (!valueSet.Contains(option.Value))
                            {
                                valueSet.Add(option.Value);
                            }
                        }
                    }
 
                    _outputColorCap = valueSet.AsReadOnly();
                }
 
                return _outputColorCap;
            }
        }
 
        /// <summary>
        /// Gets a read-only collection of <see cref="OutputQuality"/> that represents the printer's
        /// page output quality capability.
        /// </summary>
        /// <remarks>
        /// If the printer has no page output quality capability, the returned collection will be empty.
        /// </remarks>
        public ReadOnlyCollection<OutputQuality> OutputQualityCapability
        {
            get
            {
                if (_outputQualityCap == null)
                {
                    List<OutputQuality> valueSet = new List<OutputQuality>();
 
                    if (_printCap.SupportsCapability(CapabilityName.PageOutputQuality))
                    {
                        foreach (OutputQualityOption option in _printCap.PageOutputQualityCapability.OutputQualityOptions)
                        {
                            if (!valueSet.Contains(option.Value))
                            {
                                valueSet.Add(option.Value);
                            }
                        }
                    }
 
                    _outputQualityCap = valueSet.AsReadOnly();
                }
 
                return _outputQualityCap;
            }
        }
 
        /// <summary>
        /// Gets a read-only collection of <see cref="PageBorderless"/> that represents the printer's
        /// page borderless capability.
        /// </summary>
        /// <remarks>
        /// If the printer has no page borderless capability, the returned collection will be empty.
        /// </remarks>
        public ReadOnlyCollection<PageBorderless> PageBorderlessCapability
        {
            get
            {
                if (_pageBorderlessCap == null)
                {
                    List<PageBorderless> valueSet = new List<PageBorderless>();
 
                    if (_printCap.SupportsCapability(CapabilityName.PageBorderless))
                    {
                        foreach (BorderlessOption option in _printCap.PageBorderlessCapability.BorderlessOptions)
                        {
                            if (!valueSet.Contains(option.Value))
                            {
                                valueSet.Add(option.Value);
                            }
                        }
                    }
 
                    _pageBorderlessCap = valueSet.AsReadOnly();
                }
 
                return _pageBorderlessCap;
            }
        }
 
        /// <summary>
        /// Gets a <see cref="PageImageableArea"/> that represents the printer's page imageable area capability.
        /// </summary>
        /// <remarks>
        /// If the printer has no page imageable area capability, this property will return null.
        /// </remarks>
        public PageImageableArea PageImageableArea
        {
            get
            {
                if (_pageImageableArea == null)
                {
                    if (_printCap.SupportsCapability(CapabilityName.PageImageableSize) &&
                        (_printCap.PageImageableSizeCapability.ImageableArea != null))
                    {
                        CanvasImageableArea area = _printCap.PageImageableSizeCapability.ImageableArea;
 
                        if ((area.OriginWidth != PrintSchema.UnspecifiedDoubleValue) &&
                            (area.OriginHeight != PrintSchema.UnspecifiedDoubleValue) &&
                            (area.ExtentWidth != PrintSchema.UnspecifiedDoubleValue) &&
                            (area.ExtentHeight != PrintSchema.UnspecifiedDoubleValue))
                        {
                            _pageImageableArea = new PageImageableArea(area.OriginWidth,
                                                                       area.OriginHeight,
                                                                       area.ExtentWidth,
                                                                       area.ExtentHeight);
                        }
                    }
                }
 
                return _pageImageableArea;
            }
        }
 
        /// <summary>
        /// Gets a read-only collection of <see cref="PageMediaSize"/> that represents the printer's
        /// page media size capability.
        /// </summary>
        /// <remarks>
        /// If the printer has no page media size capability, the returned collection will be empty.
        /// </remarks>
        public ReadOnlyCollection<PageMediaSize> PageMediaSizeCapability
        {
            get
            {
                if (_pageMediaSizeCap == null)
                {
                    List<PageMediaSize> mediaSet = new List<PageMediaSize>();
 
                    if (_printCap.SupportsCapability(CapabilityName.PageMediaSize))
                    {
                        foreach (FixedMediaSizeOption option in _printCap.PageMediaSizeCapability.FixedMediaSizes)
                        {
                            if ((option.MediaSizeWidth != PrintSchema.UnspecifiedDoubleValue) &&
                                (option.MediaSizeHeight != PrintSchema.UnspecifiedDoubleValue))
                            {
                                mediaSet.Add(new PageMediaSize(option.Value,
                                                               option.MediaSizeWidth,
                                                               option.MediaSizeHeight));
                            }
                            else
                            {
                                mediaSet.Add(new PageMediaSize(option.Value));
                            }
                        }
                    }
 
                    _pageMediaSizeCap = mediaSet.AsReadOnly();
                }
 
                return _pageMediaSizeCap;
            }
        }
 
        /// <summary>
        /// Gets a read-only collection of <see cref="PageMediaType"/> that represents the printer's
        /// page media type capability.
        /// </summary>
        /// <remarks>
        /// If the printer has no page media type capability, the returned collection will be empty.
        /// </remarks>
        public ReadOnlyCollection<PageMediaType> PageMediaTypeCapability
        {
            get
            {
                if (_pageMediaTypeCap == null)
                {
                    List<PageMediaType> valueSet = new List<PageMediaType>();
 
                    if (_printCap.SupportsCapability(CapabilityName.PageMediaType))
                    {
                        foreach (MediaTypeOption option in _printCap.PageMediaTypeCapability.MediaTypes)
                        {
                            if (!valueSet.Contains(option.Value))
                            {
                                valueSet.Add(option.Value);
                            }
                        }
                    }
 
                    _pageMediaTypeCap = valueSet.AsReadOnly();
                }
 
                return _pageMediaTypeCap;
            }
        }
 
        /// <summary>
        /// Gets a read-only collection of <see cref="PageOrder"/> that represents the printer's
        /// job page order capability.
        /// </summary>
        /// <remarks>
        /// If the printer has no job page order capability, the returned collection will be empty.
        /// </remarks>
        public ReadOnlyCollection<PageOrder> PageOrderCapability
        {
            get
            {
                if (_pageOrderCap == null)
                {
                    List<PageOrder> valueSet = new List<PageOrder>();
 
                    if (_printCap.SupportsCapability(CapabilityName.JobPageOrder))
                    {
                        foreach (PageOrderOption option in _printCap.JobPageOrderCapability.PageOrderOptions)
                        {
                            if (!valueSet.Contains(option.Value))
                            {
                                valueSet.Add(option.Value);
                            }
                        }
                    }
 
                    _pageOrderCap = valueSet.AsReadOnly();
                }
 
                return _pageOrderCap;
            }
        }
 
        /// <summary>
        /// Gets a read-only collection of <see cref="PageOrientation"/> that represents the printer's
        /// page orientation capability.
        /// </summary>
        /// <remarks>
        /// If the printer has no page orientation capability, the returned collection will be empty.
        /// </remarks>
        public ReadOnlyCollection<PageOrientation> PageOrientationCapability
        {
            get
            {
                if (_pageOrientationCap == null)
                {
                    List<PageOrientation> valueSet = new List<PageOrientation>();
 
                    if (_printCap.SupportsCapability(CapabilityName.PageOrientation))
                    {
                        foreach (OrientationOption option in _printCap.PageOrientationCapability.Orientations)
                        {
                            if (!valueSet.Contains(option.Value))
                            {
                                valueSet.Add(option.Value);
                            }
                        }
                    }
 
                    _pageOrientationCap = valueSet.AsReadOnly();
                }
 
                return _pageOrientationCap;
            }
        }
 
        /// <summary>
        /// Gets a read-only collection of <see cref="PageResolution"/> that represents the printer's
        /// page resolution capability.
        /// </summary>
        /// <remarks>
        /// If the printer has no page resolution capability, the returned collection will be empty.
        /// </remarks>
        public ReadOnlyCollection<PageResolution> PageResolutionCapability
        {
            get
            {
                if (_pageResolutionCap == null)
                {
                    List<PageResolution> resSet = new List<PageResolution>();
 
                    if (_printCap.SupportsCapability(CapabilityName.PageResolution))
                    {
                        foreach (ResolutionOption option in _printCap.PageResolutionCapability.Resolutions)
                        {
                            if ((int)option.QualitativeResolution != PrintSchema.EnumUnspecifiedValue)
                            {
                                resSet.Add(new PageResolution(option.ResolutionX,
                                                              option.ResolutionY,
                                                              option.QualitativeResolution));
                            }
                            else
                            {
                                resSet.Add(new PageResolution(option.ResolutionX,
                                                              option.ResolutionY));
                            }
                        }
                    }
 
                    _pageResolutionCap = resSet.AsReadOnly();
                }
 
                return _pageResolutionCap;
            }
        }
 
        /// <summary>
        /// Gets a <see cref="PageScalingFactorRange"/> that represents the printer's supported range
        /// for page scaling factor.
        /// </summary>
        /// <remarks>
        /// If the printer has no page scaling capability, this property will return null.
        /// </remarks>
        public PageScalingFactorRange PageScalingFactorRange
        {
            get
            {
                if (_pageScalingFactorRange == null)
                {
                    if (_printCap.SupportsCapability(CapabilityName.PageScaling))
                    {
                        int min = -1, max = -1;
 
                        foreach (ScalingOption option in _printCap.PageScalingCapability.ScalingOptions)
                        {
                            //
                            // Going through the scaling options and find out the smallest [min, max] range
                            //
                            if (option.Value == PageScaling.Custom)
                            {
                                if ((min == -1) ||
                                    (option.CustomScaleWidth.MinValue > min))
                                {
                                    min = option.CustomScaleWidth.MinValue;
                                }
 
                                if ((max == -1) ||
                                    (option.CustomScaleWidth.MaxValue < max))
                                {
                                    max = option.CustomScaleWidth.MaxValue;
                                }
 
                                if (option.CustomScaleHeight.MinValue > min)
                                    min = option.CustomScaleHeight.MinValue;
 
                                if (option.CustomScaleHeight.MaxValue < max)
                                    max = option.CustomScaleHeight.MaxValue;
                            }
                            else if (option.Value == PageScaling.CustomSquare)
                            {
                                if ((min == -1) ||
                                    (option.CustomSquareScale.MinValue > min))
                                {
                                    min = option.CustomSquareScale.MinValue;
                                }
 
                                if ((max == -1) ||
                                    (option.CustomSquareScale.MaxValue < max))
                                {
                                    max = option.CustomSquareScale.MaxValue;
                                }
                            }
                        }
 
                        if ((min > 0) && (max > 0))
                        {
                            _pageScalingFactorRange = new PageScalingFactorRange(min, max);
                        }
                    }
                }
 
                return _pageScalingFactorRange;
            }
        }
 
        /// <summary>
        /// Gets a read-only collection of integers that represents the printer's job pages-per-sheet capability.
        /// </summary>
        /// <remarks>
        /// If the printer has no job pages-per-sheet capability, the returned collection will be empty.
        /// (Pages-per-sheet is to output multiple logical pages to a single physical sheet.)
        /// </remarks>
        public ReadOnlyCollection<int> PagesPerSheetCapability
        {
            get
            {
                if (_pagesPerSheetCap == null)
                {
                    List<int> valueSet = new List<int>();
 
                    if (_printCap.SupportsCapability(CapabilityName.JobNUp))
                    {
                        foreach (NUpOption option in _printCap.JobNUpCapability.NUps)
                        {
                            if (!valueSet.Contains(option.PagesPerSheet))
                            {
                                valueSet.Add(option.PagesPerSheet);
                            }
                        }
                    }
 
                    _pagesPerSheetCap = valueSet.AsReadOnly();
                }
 
                return _pagesPerSheetCap;
            }
        }
 
        /// <summary>
        /// Gets a read-only collection of <see cref="PagesPerSheetDirection"/> that represents the printer's
        /// job pages-per-sheet direction capability.
        /// </summary>
        /// <remarks>
        /// If the printer has no job pages-per-sheet direction capability, the returned collection will be empty.
        /// (Pages-per-sheet is to output multiple logical pages to a single physical sheet.)
        /// </remarks>
        public ReadOnlyCollection<PagesPerSheetDirection> PagesPerSheetDirectionCapability
        {
            get
            {
                if (_pagesPerSheetDirectionCap == null)
                {
                    List<PagesPerSheetDirection> valueSet = new List<PagesPerSheetDirection>();
 
                    if (_printCap.SupportsCapability(CapabilityName.JobNUp) &&
                        _printCap.JobNUpCapability.SupportsPresentationDirection)
                    {
                        foreach (NUpPresentationDirectionOption option in
                                 _printCap.JobNUpCapability.PresentationDirectionCapability.PresentationDirections)
                        {
                            if (!valueSet.Contains(option.Value))
                            {
                                valueSet.Add(option.Value);
                            }
                        }
                    }
 
                    _pagesPerSheetDirectionCap = valueSet.AsReadOnly();
                }
 
                return _pagesPerSheetDirectionCap;
            }
        }
 
        /// <summary>
        /// Gets a read-only collection of <see cref="PhotoPrintingIntent"/> that represents the printer's
        /// page photo printing intent capability.
        /// </summary>
        /// <remarks>
        /// If the printer has no page photo printing intent capability, the returned collection will be empty.
        /// </remarks>
        public ReadOnlyCollection<PhotoPrintingIntent> PhotoPrintingIntentCapability
        {
            get
            {
                if (_photoIntentCap == null)
                {
                    List<PhotoPrintingIntent> valueSet = new List<PhotoPrintingIntent>();
 
                    if (_printCap.SupportsCapability(CapabilityName.PagePhotoPrintingIntent))
                    {
                        foreach (PhotoPrintingIntentOption option in _printCap.PagePhotoPrintingIntentCapability.PhotoPrintingIntentOptions)
                        {
                            if (!valueSet.Contains(option.Value))
                            {
                                valueSet.Add(option.Value);
                            }
                        }
                    }
 
                    _photoIntentCap = valueSet.AsReadOnly();
                }
 
                return _photoIntentCap;
            }
        }
 
        /// <summary>
        /// Gets a read-only collection of <see cref="Stapling"/> that represents the printer's job output stapling capability.
        /// </summary>
        /// <remarks>
        /// If the printer has no job output stapling capability, the returned collection will be empty.
        /// </remarks>
        public ReadOnlyCollection<Stapling> StaplingCapability
        {
            get
            {
                if (_staplingCap == null)
                {
                    List<Stapling> valueSet = new List<Stapling>();
 
                    if (_printCap.SupportsCapability(CapabilityName.JobStaple))
                    {
                        foreach (StaplingOption option in _printCap.JobStapleCapability.StaplingOptions)
                        {
                            if (!valueSet.Contains(option.Value))
                            {
                                valueSet.Add(option.Value);
                            }
                        }
                    }
 
                    _staplingCap = valueSet.AsReadOnly();
                }
 
                return _staplingCap;
            }
        }
 
        /// <summary>
        /// Gets a read-only collection of <see cref="TrueTypeFontMode"/> that represents the printer's
        /// TrueType font handling mode capability.
        /// </summary>
        /// <remarks>
        /// If the printer has no TrueType font handling mode capability, the returned collection will be empty.
        /// </remarks>
        public ReadOnlyCollection<TrueTypeFontMode> TrueTypeFontModeCapability
        {
            get
            {
                if (_ttFontCap == null)
                {
                    List<TrueTypeFontMode> valueSet = new List<TrueTypeFontMode>();
 
                    if (_printCap.SupportsCapability(CapabilityName.PageTrueTypeFontMode))
                    {
                        foreach (TrueTypeFontModeOption option in _printCap.PageTrueTypeFontModeCapability.TrueTypeFontModes)
                        {
                            if (!valueSet.Contains(option.Value))
                            {
                                valueSet.Add(option.Value);
                            }
                        }
                    }
 
                    _ttFontCap = valueSet.AsReadOnly();
                }
 
                return _ttFontCap;
            }
        }
 
        #endregion Public Properties
 
        #region Private Fields
 
        private InternalPrintCapabilities _printCap;
 
        private ReadOnlyCollection<Collation> _collationCap;
        private ReadOnlyCollection<DeviceFontSubstitution> _deviceFontCap;
        private ReadOnlyCollection<Duplexing> _duplexingCap;
        private ReadOnlyCollection<InputBin> _inputBinCap;
        private Nullable<int> _maxCopyCount;
        private Nullable<double> _orientedPageMediaWidth;
        private Nullable<double> _orientedPageMediaHeight;
        private ReadOnlyCollection<OutputColor> _outputColorCap;
        private ReadOnlyCollection<OutputQuality> _outputQualityCap;
        private ReadOnlyCollection<PageBorderless> _pageBorderlessCap;
        private PageImageableArea _pageImageableArea;
        private ReadOnlyCollection<PageMediaSize> _pageMediaSizeCap;
        private ReadOnlyCollection<PageMediaType> _pageMediaTypeCap;
        private ReadOnlyCollection<PageOrder> _pageOrderCap;
        private ReadOnlyCollection<PageOrientation> _pageOrientationCap;
        private ReadOnlyCollection<PageResolution> _pageResolutionCap;
        private PageScalingFactorRange _pageScalingFactorRange;
        private ReadOnlyCollection<int> _pagesPerSheetCap;
        private ReadOnlyCollection<PagesPerSheetDirection> _pagesPerSheetDirectionCap;
        private ReadOnlyCollection<PhotoPrintingIntent> _photoIntentCap;
        private ReadOnlyCollection<Stapling> _staplingCap;
        private ReadOnlyCollection<TrueTypeFontMode> _ttFontCap;
 
        #endregion Private Fields
    }
}