JobDuplex.cs source code in C# .NET

                        Code:
                         / DotNET / DotNET / 8.0 / untmp / WIN_WINDOWS / lh_tools_devdiv_wpf / Windows / wcp / Print / Reach / PrintConfig / JobDuplex.cs / 1 / JobDuplex.cs
                        
                        
                            /*++ 

Copyright (C) 2003-2005 Microsoft Corporation
All rights reserved.
 
Module Name:
 
    JobDuplex.cs 

Abstract: 

    Definition and implementation of this public feature/parameter related types.

Author: 

    [....] ([....]) 7/1/2003 
 
--*/
 
using System;
using System.IO;
using System.Collections;
using System.Collections.ObjectModel; 
using System.Collections.Generic;
using System.Diagnostics; 
 
using System.Printing;
using MS.Internal.Printing.Configuration; 

namespace MS.Internal.Printing.Configuration
{
    ///  
    /// Represents a duplex option.
    ///  
    internal class DuplexOption: PrintCapabilityOption 
    {
        #region Constructors 

        internal DuplexOption(PrintCapabilityFeature ownerFeature) : base(ownerFeature)
        {
            _value = 0; 
        }
 
        #endregion Constructors 

        #region Public Properties 

        /// 
        /// Gets the duplexing option's value.
        ///  
        public Duplexing Value
        { 
            get 
            {
                return _value; 
            }
        }

        #endregion Public Properties 

        #region Public Methods 
 
        /// 
        /// Converts the duplex option to human-readable string. 
        /// 
        /// A string that represents this duplex option.
        public override string ToString()
        { 
            return Value.ToString();
        } 
 
        #endregion Public Methods
 
        #region Internal Fields

        internal Duplexing _value;
 
        #endregion Internal Fields
    } 
 
    /// 
    /// Represents duplex capability. 
    /// 
    abstract internal class DuplexCapability : PrintCapabilityFeature
    {
        #region Constructors 

        internal DuplexCapability(InternalPrintCapabilities ownerPrintCap) : base(ownerPrintCap) 
        { 
        }
 
        #endregion Constructors

        #region Public Properties
 
        /// 
        /// Gets the collection object that represents duplex options supported by the device. 
        ///  
        public Collection DuplexOptions
        { 
            get
            {
                return _duplexOptions;
            } 
        }
 
        #endregion Public Properties 

        #region Internal Methods 

        internal override sealed bool AddOptionCallback(PrintCapabilityOption baseOption)
        {
            bool added = false; 

            DuplexOption option = baseOption as DuplexOption; 
 
            // validate the option is complete before adding it to the collection
            if (option._optionName != null) 
            {
                int enumValue = PrintSchemaMapper.SchemaNameToEnumValueWithArray(
                                    PrintSchemaTags.Keywords.DuplexKeys.DuplexNames,
                                    PrintSchemaTags.Keywords.DuplexKeys.DuplexEnums, 
                                    option._optionName);
 
                if (enumValue > 0) 
                {
                    option._value = (Duplexing)enumValue; 
                    this.DuplexOptions.Add(option);
                    added = true;
                }
            } 

            return added; 
        } 

        internal override sealed void AddSubFeatureCallback(PrintCapabilityFeature subFeature) 
        {
            // no sub-feature
            return;
        } 

        internal override sealed bool FeaturePropCallback(PrintCapabilityFeature feature, XmlPrintCapReader reader) 
        { 
            // no feature property to handle
            return false; 
        }

        internal override sealed PrintCapabilityOption NewOptionCallback(PrintCapabilityFeature baseFeature)
        { 
            DuplexOption option = new DuplexOption(baseFeature);
 
            return option; 
        }
 
        internal override sealed void OptionAttrCallback(PrintCapabilityOption baseOption, XmlPrintCapReader reader)
        {
            // no option attribute to handle
            return; 
        }
 
        internal override sealed bool OptionPropCallback(PrintCapabilityOption baseOption, XmlPrintCapReader reader) 
        {
            // no option property to handle 
            return false;
        }

        #endregion Internal Methods 

        #region Internal Properties 
 
        internal override sealed bool IsValid
        { 
            get
            {
                return (this.DuplexOptions.Count > 0);
            } 
        }
 
        internal abstract override string FeatureName 
        {
            get; 
        }

        internal override sealed bool HasSubFeature
        { 
            get
            { 
                return false; 
            }
        } 

        #endregion Internal Properties

        #region Internal Fields 

        internal Collection _duplexOptions; 
 
        #endregion Internal Fields
    } 

    /// 
    /// Represents job duplex capability.
    ///  
    internal class JobDuplexCapability : DuplexCapability
    { 
        #region Constructors 

        internal JobDuplexCapability(InternalPrintCapabilities ownerPrintCap) : base(ownerPrintCap) 
        {
        }

        #endregion Constructors 

        #region Internal Methods 
 
        internal static PrintCapabilityFeature NewFeatureCallback(InternalPrintCapabilities printCap)
        { 
            JobDuplexCapability cap = new JobDuplexCapability(printCap);
            cap._duplexOptions = new Collection();

            return cap; 
        }
 
        #endregion Internal Methods 

        #region Internal Properties 

        internal override sealed string FeatureName
        {
            get 
            {
                return PrintSchemaTags.Keywords.DuplexKeys.JobDuplex; 
            } 
        }
 
        #endregion Internal Properties
    }

    ///  
    /// Represents duplex setting.
    ///  
    abstract internal class DuplexSetting : PrintTicketFeature 
    {
        #region Constructors 

        /// 
        /// Constructs a new duplex setting object.
        ///  
        internal DuplexSetting(InternalPrintTicket ownerPrintTicket, string featureName)
            : base(ownerPrintTicket) 
        { 
            this._featureName = featureName;
 
            this._propertyMaps = new PTPropertyMapEntry[] {
                new PTPropertyMapEntry(this,
                                       PrintSchemaTags.Framework.OptionNameProperty,
                                       PTPropValueTypes.EnumStringValue, 
                                       PrintSchemaTags.Keywords.DuplexKeys.DuplexNames,
                                       PrintSchemaTags.Keywords.DuplexKeys.DuplexEnums), 
                }; 
        }
 
        #endregion Constructors

        #region Public Properties
 
        /// 
        /// Gets or sets the value of this duplex setting. 
        ///  
        /// 
        /// If the setting is not specified yet, getter will return 0. 
        /// 
        /// 
        /// The value to set is not one of the standard .
        ///  
        public Duplexing Value
        { 
            get 
            {
                return (Duplexing)this[PrintSchemaTags.Framework.OptionNameProperty]; 
            }
            set
            {
                if (value < PrintSchema.DuplexingEnumMin || 
                    value > PrintSchema.DuplexingEnumMax)
                { 
                    throw new ArgumentOutOfRangeException("value"); 
                }
 
                this[PrintSchemaTags.Framework.OptionNameProperty] = (int)value;
            }
        }
 
        #endregion Public Properties
 
        #region Public Methods 

        ///  
        /// Converts the duplex setting to human-readable string.
        /// 
        /// A string that represents this duplex setting.
        public override string ToString() 
        {
            return Value.ToString(); 
        } 

        #endregion Public Methods 
    }

    /// 
    /// Represents job duplex setting. 
    /// 
    internal class JobDuplexSetting : DuplexSetting 
    { 
        #region Constructors
 
        internal JobDuplexSetting(InternalPrintTicket ownerPrintTicket)
            : base(ownerPrintTicket, PrintSchemaTags.Keywords.DuplexKeys.JobDuplex)
        {
        } 

        #endregion Constructors 
    } 
}

// File provided for Reference Use Only by Microsoft Corporation (c) 2007.
// Copyright (c) Microsoft Corporation. All rights reserved.
Link Menu

Network programming in C#, Network Programming in VB.NET, Network Programming in .NET
This book is available now!
Buy at Amazon US or
Buy at Amazon UK
JobDuplex.cs source code in C# .NET

Source code for the .NET framework in C#

Code:

Link Menu
