mono/mcs/class/System.Drawing/System.Drawing.Printing/PrinterSettings.cs

//
// System.Drawing.PrinterSettings.cs
//
// Authors:
//   Dennis Hayes ([email protected])
//   Herve Poussineau ([email protected])
//   Andreas Nahr ([email protected])
//
// (C) 2002 Ximian, Inc
// Copyright (C) 2004,2006 Novell, Inc (http://www.novell.com)
//
// Permission is hereby granted, free of charge, to any person obtaining
// a copy of this software and associated documentation files (the
// "Software"), to deal in the Software without restriction, including
// without limitation the rights to use, copy, modify, merge, publish,
// distribute, sublicense, and/or sell copies of the Software, and to
// permit persons to whom the Software is furnished to do so, subject to
// the following conditions:
// 
// The above copyright notice and this permission notice shall be
// included in all copies or substantial portions of the Software.
// 
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
//

using System.Runtime.InteropServices;
using System.Collections;
using System.Collections.Specialized;
using System.ComponentModel;
using System.Drawing.Imaging;

namespace System.Drawing.Printing
{
	[Serializable]
#if ! NET_2_0
	[ComVisible(false)]
#endif	
	public class PrinterSettings : ICloneable
	{
		private string printer_name;
		private string print_filename;
		private short copies;
		private int maximum_page;
		private int minimum_page; 
		private int from_page;
		private int to_page;
		private bool collate;
		private PrintRange print_range;
		internal int maximum_copies;
		internal bool can_duplex;
		internal bool supports_color;
		internal int landscape_angle;		
		private bool print_tofile;
		internal PrinterSettings.PrinterResolutionCollection printer_resolutions;
		internal PrinterSettings.PaperSizeCollection paper_sizes;
		internal PrinterSettings.PaperSourceCollection paper_sources;
		private PageSettings default_pagesettings;
		private Duplex duplex;
		internal bool is_plotter;
		private PrintingServices printing_services;
		
		internal NameValueCollection printer_capabilities; // this stores a list of all the printer options. Used only in cups, but might come in handy on win too.
		public PrinterSettings() : this (SysPrn.CreatePrintingService ())
		{			
			print_tofile = false;
		}
		
		internal PrinterSettings (PrintingServices printing_services)
		{
			this.printing_services = printing_services;
			printer_name = printing_services.DefaultPrinter;
			ResetToDefaults ();
			printing_services.LoadPrinterSettings (printer_name, this);
		}
		
		private void ResetToDefaults ()
		{			
			printer_resolutions = null;
			paper_sizes = null;
			paper_sources = null;
			default_pagesettings = null;
			maximum_page = 9999; 	
			copies = 1;
			collate = true;
		}
	
		//properties
		
		public bool CanDuplex
		{
			get { return can_duplex; }
		}
		
		public bool Collate
		{
			get { return collate; }
			set { collate = value; }
		}

		public short Copies
		{
			get { return copies; }
			set { 
				if (value < 0)
					throw new ArgumentException ("The value of the Copies property is less than zero.");
				
				copies = value;
			}
		}
		
		public PageSettings DefaultPageSettings
		{
			get {
				if (default_pagesettings == null) {
					default_pagesettings = new PageSettings (this,
						SupportsColor,
						false,	
						// Real defaults are set by LoadPrinterSettings				
						new PaperSize("A4", 827, 1169),						
						new PaperSource("Tray", PaperSourceKind.FormSource),						
						new PrinterResolution(200, 200, PrinterResolutionKind.Medium));
				}
				
				return default_pagesettings;
			}
		}

		public Duplex Duplex
		{
			get { return this.duplex; }
			set { this.duplex = value; }
		}
		
		public int FromPage
		{
			get { return from_page; }
			set {
				if (value < 0)
					throw new ArgumentException ("The value of the FromPage property is less than zero");
				
				from_page = value;
			}
		}
		
		public static PrinterSettings.StringCollection InstalledPrinters
		{
			get { return SysPrn.GlobalService.InstalledPrinters; }
		}
	
		public bool IsDefaultPrinter
		{
			get { return (printer_name == printing_services.DefaultPrinter); }
		}

		public bool IsPlotter
		{
			get { return is_plotter; }
		}

		public bool IsValid
		{
			get { return printing_services.IsPrinterValid (this.printer_name); }
		}
		
		public int LandscapeAngle
		{
			get { return landscape_angle; }
		}
		
		public int MaximumCopies
		{
			get { return maximum_copies; }
		}
		
		public int MaximumPage
		{
			get { return maximum_page; }
			set {
				// This not documented but behaves like MinimumPage
				if (value < 0)
					throw new ArgumentException ("The value of the MaximumPage property is less than zero");
				
				maximum_page = value;
			}
		}
		
		public int MinimumPage
		{
			get { return minimum_page; }
			set {
				if (value < 0)
					throw new ArgumentException ("The value of the MaximumPage property is less than zero");
				
				minimum_page = value;
			}
		}
		
		public PrinterSettings.PaperSizeCollection PaperSizes
		{
			get {
				if (!this.IsValid)
					throw new InvalidPrinterException(this);

				return paper_sizes;				
			}
		}

		public PrinterSettings.PaperSourceCollection PaperSources
		{
			get {
				if (!this.IsValid)
					throw new InvalidPrinterException(this);

				return paper_sources;
			}
		}
#if NET_2_0
		public
#else
		internal
#endif
		string PrintFileName
		{
			get { return print_filename; }
			set { print_filename = value; }
		}
		public string PrinterName
		{
			get { return printer_name; }
			set { 
				if (printer_name == value)
					return;
					
				printer_name = value;
				printing_services.LoadPrinterSettings (printer_name, this);
			}
		}
		
		public PrinterSettings.PrinterResolutionCollection PrinterResolutions
		{
			get {
				if (!this.IsValid)
					throw new InvalidPrinterException(this);
					
				if (printer_resolutions == null) {
					printer_resolutions = new PrinterSettings.PrinterResolutionCollection (new PrinterResolution[] {});
					printing_services.LoadPrinterResolutions (printer_name, this);
				}
				
				return printer_resolutions;
			}
		}
		
		public PrintRange PrintRange
		{
			get { return print_range; }
			set { 
				if (value != PrintRange.AllPages && value != PrintRange.Selection &&
					value != PrintRange.SomePages)
					throw new InvalidEnumArgumentException ("The value of the PrintRange property is not one of the PrintRange values");
				
				print_range = value;
			}
		}
		
		public bool PrintToFile
		{
			get { return print_tofile; }
			set { print_tofile = value; }
		}
		
		public bool SupportsColor
		{
			get { return supports_color; }
		}
		
		public int ToPage
		{
			get { return to_page; }
			set {
				if (value < 0)
					throw new ArgumentException ("The value of the ToPage property is less than zero");
				
				to_page = value;
			}		
		}
		
		internal NameValueCollection PrinterCapabilities {
			get { 
				if (this.printer_capabilities == null)
					this.printer_capabilities = new NameValueCollection();
				return this.printer_capabilities;
			}
		}

		//methods		
		public object Clone ()
		{
			PrinterSettings ps = new PrinterSettings (printing_services);
			return ps;
		}

		[MonoTODO("PrinterSettings.CreateMeasurementGraphics")]
		public Graphics CreateMeasurementGraphics()
		{
			throw new NotImplementedException();
		}
#if NET_2_0
		[MonoTODO("PrinterSettings.CreateMeasurementGraphics")]
		public Graphics CreateMeasurementGraphics(bool honorOriginAtMargins)		
		{
			throw new NotImplementedException();
		}
		
		[MonoTODO("PrinterSettings.CreateMeasurementGraphics")]
		public Graphics CreateMeasurementGraphics(PageSettings pageSettings)		
		{
			throw new NotImplementedException();
		}
		
		[MonoTODO("PrinterSettings.CreateMeasurementGraphics")]
		public Graphics CreateMeasurementGraphics (PageSettings pageSettings, bool honorOriginAtMargins)		
		{
			throw new NotImplementedException();
		} 
#endif		

		[MonoTODO("PrinterSettings.GetHdevmode")]
		public IntPtr GetHdevmode()
		{
			throw new NotImplementedException();
		}

		[MonoTODO("PrinterSettings.GetHdevmode")]
		public IntPtr GetHdevmode(PageSettings pageSettings)
		{
			throw new NotImplementedException();
		}

		[MonoTODO("PrinterSettings.GetHdevname")]
		public IntPtr GetHdevnames()
		{
			throw new NotImplementedException();
		}
		
#if NET_2_0

		[MonoTODO("IsDirectPrintingSupported")]
		public bool IsDirectPrintingSupported (Image image)
		{
			throw new NotImplementedException();
		}
		
		[MonoTODO("IsDirectPrintingSupported")]
		public bool IsDirectPrintingSupported (ImageFormat imageFormat)
		{
			throw new NotImplementedException();
		}
#endif

		[MonoTODO("PrinterSettings.SetHdevmode")]
		public void SetHdevmode(IntPtr hdevmode)
		{
			throw new NotImplementedException();
		}

		[MonoTODO("PrinterSettings.SetHdevnames")]
		public void SetHdevnames(IntPtr hdevnames)
		{
			throw new NotImplementedException();
		}
		
		public override string ToString()
		{
			return "Printer [PrinterSettings " + printer_name + " Copies=" + copies +  " Collate=" + collate 
			+ " Duplex=" + can_duplex + " FromPage=" + from_page + " LandscapeAngle=" + landscape_angle 
			+ " MaximumCopies=" + maximum_copies + " OutputPort=" + " ToPage=" + to_page + "]";

		}
		
		// Public subclasses
		#region Public Subclasses
		

		public class PaperSourceCollection : ICollection, IEnumerable
		{
			ArrayList _PaperSources = new ArrayList();
			
			public PaperSourceCollection(PaperSource[] array) {
				foreach (PaperSource ps in array)
					_PaperSources.Add(ps);
			}
			
			public int Count { get { return _PaperSources.Count; } }
			int ICollection.Count { get { return _PaperSources.Count; } }
			bool ICollection.IsSynchronized { get { return false; } }
			object ICollection.SyncRoot { get { return this; } }			
#if NET_2_0
			[EditorBrowsable(EditorBrowsableState.Never)]
      			public int Add (PaperSource paperSource) {return _PaperSources.Add (paperSource); }
			public void CopyTo (PaperSource[] paperSources, int index)  {throw new NotImplementedException (); }
#else
			internal int Add (PaperSource paperSource) {return _PaperSources.Add (paperSource); }
#endif
			
			public virtual PaperSource this[int index] {
				get { return _PaperSources[index] as PaperSource; }
			}
			
			IEnumerator IEnumerable.GetEnumerator()
			{
				return _PaperSources.GetEnumerator();
			}
			
			public IEnumerator GetEnumerator()
			{
				return _PaperSources.GetEnumerator();
			}
			
			void ICollection.CopyTo(Array array, int index)
			{
				_PaperSources.CopyTo(array, index);
			}
			
			internal void Clear ()
			{ 
				_PaperSources.Clear (); 
			}
			
		}

		public class PaperSizeCollection : ICollection, IEnumerable
		{
			ArrayList _PaperSizes = new ArrayList();
			
			public PaperSizeCollection(PaperSize[] array) {
				foreach (PaperSize ps in array)
					_PaperSizes.Add(ps);
			}
			
			public int Count { get { return _PaperSizes.Count; } }
			int ICollection.Count { get { return _PaperSizes.Count; } }
			bool ICollection.IsSynchronized { get { return false; } }
			object ICollection.SyncRoot { get { return this; } }			
#if NET_2_0		
			[EditorBrowsable(EditorBrowsableState.Never)]
			public int Add (PaperSize paperSize) {return _PaperSizes.Add (paperSize); }	
			public void CopyTo (PaperSize[] paperSizes, int index) {throw new NotImplementedException (); }			
#else
			internal int Add (PaperSize paperSize) {return _PaperSizes.Add (paperSize); }	
#endif
			
			public virtual PaperSize this[int index] {
				get { return _PaperSizes[index] as PaperSize; }
			}
			
			IEnumerator IEnumerable.GetEnumerator()
			{
				return _PaperSizes.GetEnumerator();
			}
			
			public IEnumerator GetEnumerator()
			{
				return _PaperSizes.GetEnumerator();
			}
			
			void ICollection.CopyTo(Array array, int index)
			{
				_PaperSizes.CopyTo(array, index);
			}
			
			internal void Clear ()
			{ 
				_PaperSizes.Clear (); 
			}
		}

		public class PrinterResolutionCollection : ICollection, IEnumerable
		{
			ArrayList _PrinterResolutions = new ArrayList();
			
			public PrinterResolutionCollection(PrinterResolution[] array) {
				foreach (PrinterResolution pr in array)
					_PrinterResolutions.Add(pr);
			}
			
			public int Count { get { return _PrinterResolutions.Count; } }
			int ICollection.Count { get { return _PrinterResolutions.Count; } }
			bool ICollection.IsSynchronized { get { return false; } }
			object ICollection.SyncRoot { get { return this; } }			
#if NET_2_0
			[EditorBrowsable(EditorBrowsableState.Never)]
			public int Add (PrinterResolution printerResolution) { return _PrinterResolutions.Add (printerResolution); }
			public void CopyTo (PrinterResolution[] printerResolutions, int index) {throw new NotImplementedException (); }
#else
			internal int Add (PrinterResolution printerResolution) { return _PrinterResolutions.Add (printerResolution); }
#endif
						
			public virtual PrinterResolution this[int index] {
				get { return _PrinterResolutions[index] as PrinterResolution; }
			}
			
			IEnumerator IEnumerable.GetEnumerator()
			{
				return _PrinterResolutions.GetEnumerator();
			}
			
			public IEnumerator GetEnumerator()
			{
				return _PrinterResolutions.GetEnumerator();
			}
			
			void ICollection.CopyTo(Array array, int index)
			{
				_PrinterResolutions.CopyTo(array, index);
			}
			
			internal void Clear ()
			{ 
				_PrinterResolutions.Clear (); 
			}
		}

		public class StringCollection : ICollection, IEnumerable
		{
			ArrayList _Strings = new ArrayList();
			
			public StringCollection(string[] array) {
				foreach (string s in array)
					_Strings.Add(s);
			}
			
			public int Count { get { return _Strings.Count; } }
			int ICollection.Count { get { return _Strings.Count; } }
			bool ICollection.IsSynchronized { get { return false; } }
			object ICollection.SyncRoot { get { return this; } }
						
			public virtual string this[int index] {
				get { return _Strings[index] as string; }
			}
#if NET_2_0
			[EditorBrowsable(EditorBrowsableState.Never)]
      			public int Add (string value) { return _Strings.Add (value); }
      			public void CopyTo (string[] strings, int index) {throw new NotImplementedException (); }      			
#else
			internal int Add (string value) { return _Strings.Add (value); }
#endif

			IEnumerator IEnumerable.GetEnumerator()
			{
				return _Strings.GetEnumerator();
			}
			
			public IEnumerator GetEnumerator()
			{
				return _Strings.GetEnumerator();
			}
			
			void ICollection.CopyTo(Array array, int index)
			{
				_Strings.CopyTo(array, index);
			}			
		}
		
		#endregion

		void GetPrintDialogInfo (string printer_name, ref string port, ref string type, ref string status, ref string comment)
		{
			printing_services.GetPrintDialogInfo (printer_name, ref port, ref type, ref status, ref comment);
		}
	}
}