//#define PrintDebug
//
// Copyright (C) 2005, 2007 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.
//
// Author:
//
//	Jordi Mas i Hernandez, jordimash@gmail.com
//

using System.Runtime.InteropServices;
using System.Collections;
using System.Collections.Specialized;
using System.Drawing.Printing;
using System.ComponentModel;
using System.Drawing.Imaging;
using System.Text;
using System.IO;

namespace System.Drawing.Printing
{
	internal class PrintingServicesUnix : PrintingServices
	{
		#region Private Fields
		
		private static Hashtable doc_info = new Hashtable ();
		private static bool cups_installed;
		
		//private string printer_name;
		
		private static Hashtable installed_printers;
		private static string default_printer = String.Empty;
				
		#endregion

		#region Constructor

		internal PrintingServicesUnix () {
		}
		
		static PrintingServicesUnix () {
			installed_printers = new Hashtable ();
			CheckCupsInstalled ();
		}
		
		#endregion

		#region Properties

		internal static PrinterSettings.StringCollection InstalledPrinters {
			get {
				LoadPrinters();
				PrinterSettings.StringCollection list = new PrinterSettings.StringCollection (new string[] {});
				foreach (object key in installed_printers.Keys) {
					list.Add (key.ToString());
				}
				return list;
			}
		}

		internal override string DefaultPrinter {
			get {
				if (installed_printers.Count == 0)
					LoadPrinters();
				return default_printer;
			}
		}
		
		#endregion


		#region Methods

		/// <summary>
		/// Do a cups call to check if it is installed
		/// </summary>
		private static void CheckCupsInstalled ()
		{
			try {
				cupsGetDefault ();
			}
			catch (DllNotFoundException) {
				Console.WriteLine("libcups not found. To have printing support, you need cups installed");
				cups_installed = false;
				return;
			}

			cups_installed = true;
		}

		/// <summary>
		/// Open the printer's PPD file
		/// </summary>
		/// <param name="printer">Printer name, returned from cupsGetDests</param>
		private IntPtr OpenPrinter (string printer)
		{
			try {
				IntPtr ptr = cupsGetPPD (printer);
				string ppd_filename = Marshal.PtrToStringAnsi (ptr);
				IntPtr ppd_handle = ppdOpenFile (ppd_filename);
				return ppd_handle;
			}
			catch (Exception) {
				Console.WriteLine ("There was an error opening the printer {0}. Please check your cups installation.");
			}
			return IntPtr.Zero;
		}

		/// <summary>
		/// Close the printer file
		/// </summary>
		/// <param name="handle">PPD handle</param>
		private void ClosePrinter (ref IntPtr handle)
		{
			try {
				if (handle != IntPtr.Zero)
					ppdClose (handle);
			}
			finally {
				handle = IntPtr.Zero;
			}
		}

		private static int OpenDests (ref IntPtr ptr) {
			try {
				return cupsGetDests (ref ptr);
			}
			catch {
				ptr = IntPtr.Zero;
			}
			return 0;
		}

		private static void CloseDests (ref IntPtr ptr, int count) {
			try {
				if (ptr != IntPtr.Zero)
					cupsFreeDests (count, ptr);
			}
			finally {
				ptr = IntPtr.Zero;
			}
		}

		/// <summary>
		/// Checks if a printer has a valid PPD file. Caches the result unless force is true
		/// </summary>
		/// <param name="force">Does the check disregarding the last cached value if true</param>
		internal override bool IsPrinterValid(string printer)
		{
			if (!cups_installed || printer == null | printer == String.Empty)
				return false;
				
			return installed_printers.Contains (printer);
/*
			if (!force && this.printer_name != null && String.Intern(this.printer_name).Equals(printer))
				return is_printer_valid;

			IntPtr ptr = cupsGetPPD (printer);
			string ppd_filename = Marshal.PtrToStringAnsi (ptr);
			is_printer_valid = ppd_filename != null;
			this.printer_name = printer; 
			return is_printer_valid;
*/			
		}
	
		/// <summary>
		/// Loads the printer settings and initializes the PrinterSettings and PageSettings fields
		/// </summary>
		/// <param name="printer">Printer name</param>
		/// <param name="settings">PrinterSettings object to initialize</param>
		internal override void LoadPrinterSettings (string printer, PrinterSettings settings)
		{
			if (cups_installed == false || (printer == null) || (printer == String.Empty))
				return;

			if (installed_printers.Count == 0)
				LoadPrinters ();

			if (((SysPrn.Printer)installed_printers[printer]).Settings != null) {
				SysPrn.Printer p = (SysPrn.Printer) installed_printers[printer];
				settings.can_duplex = p.Settings.can_duplex;
				settings.is_plotter = p.Settings.is_plotter;
				settings.landscape_angle = p.Settings.landscape_angle;
				settings.maximum_copies = p.Settings.maximum_copies;
				settings.paper_sizes = p.Settings.paper_sizes;
				settings.paper_sources = p.Settings.paper_sources;
				settings.printer_capabilities = p.Settings.printer_capabilities;
				settings.printer_resolutions = p.Settings.printer_resolutions;
				settings.supports_color = p.Settings.supports_color;
				return;
			}

			settings.PrinterCapabilities.Clear ();

			IntPtr dests = IntPtr.Zero, ptr = IntPtr.Zero, ptr_printer, ppd_handle = IntPtr.Zero;
			string name = String.Empty;
			CUPS_DESTS printer_dest;
			PPD_FILE ppd;
			int ret = 0, cups_dests_size;
			NameValueCollection options, paper_names, paper_sources;

			try {
				ret = OpenDests (ref dests);
				if (ret == 0)
					return;

				cups_dests_size = Marshal.SizeOf (typeof(CUPS_DESTS));
				ptr = dests;
				for (int i = 0; i < ret; i++) {
					ptr_printer = (IntPtr) Marshal.ReadIntPtr (ptr);
					if (Marshal.PtrToStringAnsi (ptr_printer).Equals(printer)) {
						name = printer;
						break;
					}
					ptr = (IntPtr) ((long)ptr + cups_dests_size);
				}
			
				if (!name.Equals(printer)) {
					return;
				}

				ppd_handle = OpenPrinter (printer);
				if (ppd_handle == IntPtr.Zero)
					return;

				printer_dest = (CUPS_DESTS) Marshal.PtrToStructure (ptr, typeof (CUPS_DESTS));
				options = new NameValueCollection();
				paper_names = new NameValueCollection();
				paper_sources = new NameValueCollection();
				string defsize;
				string defsource;
				LoadPrinterOptions (printer_dest.options, printer_dest.num_options, ppd_handle, options,
					paper_names, out defsize,
					paper_sources, out defsource);

				if (settings.paper_sizes == null)
					settings.paper_sizes = new PrinterSettings.PaperSizeCollection (new PaperSize [] {});
				else
					settings.paper_sizes.Clear();
			
				if (settings.paper_sources == null)				
					settings.paper_sources = new PrinterSettings.PaperSourceCollection (new PaperSource [] {});
				else
					settings.paper_sources.Clear();

				settings.DefaultPageSettings.PaperSource = LoadPrinterPaperSources (settings, defsource, paper_sources);
				settings.DefaultPageSettings.PaperSize = LoadPrinterPaperSizes (ppd_handle, settings, defsize, paper_names);
				LoadPrinterResolutionsAndDefault (printer, settings, ppd_handle);

				ppd = (PPD_FILE) Marshal.PtrToStructure (ppd_handle, typeof (PPD_FILE));
				settings.landscape_angle = ppd.landscape;
				settings.supports_color = (ppd.color_device == 0) ? false : true;
				settings.can_duplex = options["Duplex"] != null;

				ClosePrinter (ref ppd_handle);
			
				((SysPrn.Printer)installed_printers[printer]).Settings = settings;
			}
			finally {
				CloseDests (ref dests, ret);
			}
		}
		
		/// <summary>
		/// Loads the global options of a printer plus the paper types and trays supported,
		/// and sets the default paper size and source tray.
		/// </summary>
		/// <param name="options">The options field of a printer's CUPS_DESTS structure</param>
		/// <param name="numOptions">The number of options of the printer</param>
		/// <param name="ppd">A ppd handle for the printer, returned by ppdOpen</param>
		/// <param name="list">The list of options</param>
		/// <param name="paper_names">A list of types of paper (PageSize)</param>
		/// <param name="defsize">The default paper size, set by LoadOptionList</param>
		/// <param name="paper_sources">A list of trays(InputSlot) </param>
		/// <param name="defsource">The default source tray, set by LoadOptionList</param>
		private static void LoadPrinterOptions(IntPtr options, int numOptions, IntPtr ppd, 
										 NameValueCollection list, 
										 NameValueCollection paper_names, out string defsize,
										 NameValueCollection paper_sources, out string defsource)
		{
			CUPS_OPTIONS cups_options;
			string option_name, option_value;
			int cups_size = Marshal.SizeOf(typeof(CUPS_OPTIONS));
			
			for (int j = 0; j < numOptions; j++)
			{
				cups_options = (CUPS_OPTIONS) Marshal.PtrToStructure(options, typeof(CUPS_OPTIONS));
				option_name = Marshal.PtrToStringAnsi(cups_options.name);
				option_value = Marshal.PtrToStringAnsi(cups_options.val);

				#if PrintDebug
				Console.WriteLine("{0} = {1}", option_name, option_value);
				#endif
				
				list.Add(option_name, option_value);

				options = (IntPtr) ((long)options + cups_size);
			}
			
			LoadOptionList (ppd, "PageSize", paper_names, out defsize);
			LoadOptionList (ppd, "InputSlot", paper_sources, out defsource);
		}
		
		/// <summary>
		/// Loads the global options of a printer. 
		/// </summary>
		/// <param name="options">The options field of a printer's CUPS_DESTS structure</param>
		/// <param name="numOptions">The number of options of the printer</param>
		private static NameValueCollection LoadPrinterOptions(IntPtr options, int numOptions)
		{
			CUPS_OPTIONS cups_options;
			string option_name, option_value;
			int cups_size = Marshal.SizeOf (typeof(CUPS_OPTIONS));
			NameValueCollection list = new NameValueCollection ();
			for (int j = 0; j < numOptions; j++)
			{
				cups_options = (CUPS_OPTIONS) Marshal.PtrToStructure(options, typeof(CUPS_OPTIONS));
				option_name = Marshal.PtrToStringAnsi (cups_options.name);
				option_value = Marshal.PtrToStringAnsi (cups_options.val);
				
				#if PrintDebug
				Console.WriteLine("{0} = {1}", option_name, option_value);
				#endif
				
				list.Add (option_name, option_value);

				options = (IntPtr) ((long)options + cups_size);
			}
			return list;
		}

		/// <summary>
		/// Loads a printer's options (selection of paper sizes, paper sources, etc)
		/// and sets the default option from the selected list.
		/// </summary>
		/// <param name="ppd">Printer ppd file handle</param>
		/// <param name="option_name">Name of the option group to load</param>
		/// <param name="list">List of loaded options</param>
		/// <param name="defoption">The default option from the loaded options list</param>
		private static void LoadOptionList (IntPtr ppd, string option_name, NameValueCollection list, out string defoption) {

			IntPtr ptr = IntPtr.Zero;
			PPD_OPTION ppd_option;
			PPD_CHOICE choice;
			int choice_size = Marshal.SizeOf(typeof(PPD_CHOICE)); 
			defoption = null;
			
			ptr = ppdFindOption (ppd, option_name);
			if (ptr != IntPtr.Zero)
			{
				ppd_option = (PPD_OPTION) Marshal.PtrToStructure (ptr, typeof (PPD_OPTION));
				#if PrintDebug
				Console.WriteLine (" OPTION  key:{0} def:{1} text: {2}", ppd_option.keyword, ppd_option.defchoice, ppd_option.text);
				#endif
				defoption = ppd_option.defchoice;
				ptr = ppd_option.choices;
				for (int c = 0; c < ppd_option.num_choices; c++) {
					choice = (PPD_CHOICE) Marshal.PtrToStructure (ptr, typeof (PPD_CHOICE));
					list.Add(choice.choice, choice.text);
					#if PrintDebug
					Console.WriteLine ("       choice:{0} - text: {1}", choice.choice, choice.text);
					#endif

					ptr = (IntPtr) ((long)ptr + choice_size);
				}
			}		
		}

		/// <summary>
		/// Loads a printer's available resolutions
		/// </summary>
		/// <param name="printer">Printer name</param>
		/// <param name="settings">PrinterSettings object to fill</param>
		internal override void LoadPrinterResolutions (string printer, PrinterSettings settings)
		{
			IntPtr ppd_handle = OpenPrinter (printer);
			if (ppd_handle == IntPtr.Zero)
				return;

			LoadPrinterResolutionsAndDefault (printer, settings, ppd_handle);

			ClosePrinter (ref ppd_handle);
		}

		/// <summary>
		/// Create a PrinterResolution from a string Resolution that is set in the PPD option.
		/// An example of Resolution is "600x600dpi" or "600dpi". Returns null if malformed or "Unknown".
		/// </summary>
		private PrinterResolution ParseResolution (string resolution)
		{
			if (String.IsNullOrEmpty (resolution))
				return null;

			int dpiIndex = resolution.IndexOf ("dpi");
			if (dpiIndex == -1)
			{
				// Resolution is "Unknown" or unparsable
				return null;
			}
			resolution = resolution.Substring (0, dpiIndex);

			int x_resolution, y_resolution;
			try {
				if (resolution.Contains ("x")) {
					string[] resolutions = resolution.Split (new[] {'x'});
					x_resolution = Convert.ToInt32 (resolutions [0]);
					y_resolution = Convert.ToInt32 (resolutions [1]);
				} else {
					x_resolution = Convert.ToInt32 (resolution);
					y_resolution = x_resolution;
				}
			} catch (Exception) {
				return null;
			}

			return new PrinterResolution (x_resolution, y_resolution, PrinterResolutionKind.Custom);
		}

		/// <summary>
		/// Loads a printer's paper sizes. Returns the default PaperSize, and fills a list of paper_names for use in dialogues
		/// </summary>
		/// <param name="ppd_handle">PPD printer file handle</param>
		/// <param name="settings">PrinterSettings object to fill</param>
		/// <param name="def_size">Default paper size, from the global options of the printer</param>
		/// <param name="paper_names">List of available paper sizes that gets filled</param>
		private PaperSize LoadPrinterPaperSizes(IntPtr ppd_handle, PrinterSettings settings, 
												string def_size, NameValueCollection paper_names)
		{
			IntPtr ptr;
			string real_name;
			PPD_FILE ppd;
			PPD_SIZE size;
			PaperSize ps;

			PaperSize defsize = new PaperSize ("A4", 827, 1169, GetPaperKind (827, 1169), true);
			ppd = (PPD_FILE) Marshal.PtrToStructure (ppd_handle, typeof (PPD_FILE));
			ptr = ppd.sizes;
			float w, h;
			for (int i = 0; i < ppd.num_sizes; i++) {
				size = (PPD_SIZE) Marshal.PtrToStructure (ptr, typeof (PPD_SIZE));
				real_name = paper_names[size.name];
				w = size.width * 100 / 72;
				h = size.length * 100 / 72;
				PaperKind kind = GetPaperKind ((int) w, (int) h);
				ps = new PaperSize (real_name, (int) w, (int) h, kind, def_size == kind.ToString ());
				ps.SetKind (kind);
				if (def_size == ps.Kind.ToString ())
					defsize = ps;
				settings.paper_sizes.Add (ps);
				ptr = (IntPtr) ((long)ptr + Marshal.SizeOf (size));
			}
			
			return defsize;

		}
		
		/// <summary>
		/// Loads a printer's paper sources (trays). Returns the default PaperSource, and fills a list of paper_sources for use in dialogues
		/// </summary>
		/// <param name="settings">PrinterSettings object to fill</param>
		/// <param name="def_source">Default paper source, from the global options of the printer</param>
		/// <param name="paper_sources">List of available paper sizes that gets filled</param>
		private PaperSource LoadPrinterPaperSources (PrinterSettings settings, string def_source, 
													NameValueCollection paper_sources)
		{
			PaperSourceKind kind;
			PaperSource defsource = null;
			foreach(string source in paper_sources) {
				switch (source)
				{
					case "Auto":
						kind = PaperSourceKind.AutomaticFeed;
						break;
					case "Standard":
						kind = PaperSourceKind.AutomaticFeed;
						break;
					case "Tray":
						kind = PaperSourceKind.AutomaticFeed;
						break;
					case "Envelope":
						kind = PaperSourceKind.Envelope;
						break;
					case "Manual":
						kind = PaperSourceKind.Manual;
						break;
					default:
						kind = PaperSourceKind.Custom;
						break;
				}
				settings.paper_sources.Add (new PaperSource (paper_sources[source], kind, def_source == source));
				if (def_source == source)
					defsource = settings.paper_sources[settings.paper_sources.Count-1];
			}
			
			if (defsource == null && settings.paper_sources.Count > 0)
				return settings.paper_sources[0];
			return defsource;
		}

		/// <summary>
		/// Sets the available resolutions and default resolution from a
		/// printer's PPD file into settings.
		/// </summary>
		private void LoadPrinterResolutionsAndDefault (string printer,
			PrinterSettings settings, IntPtr ppd_handle)
		{
			if (settings.printer_resolutions == null)
				settings.printer_resolutions = new PrinterSettings.PrinterResolutionCollection (new PrinterResolution [] {});
			else
				settings.printer_resolutions.Clear ();

			var printer_resolutions = new NameValueCollection ();
			string defresolution;
			LoadOptionList (ppd_handle, "Resolution", printer_resolutions, out defresolution);
			foreach (var resolution in printer_resolutions.Keys) {
				var new_resolution = ParseResolution (resolution.ToString ());
				settings.PrinterResolutions.Add (new_resolution);
			}

			var default_resolution = ParseResolution (defresolution);

			if (default_resolution == null)
				default_resolution = ParseResolution ("300dpi");
			if (printer_resolutions.Count == 0)
				settings.PrinterResolutions.Add (default_resolution);

			settings.DefaultPageSettings.PrinterResolution = default_resolution;
		}

		/// <summary>
		/// </summary>
		/// <param name="load"></param>
		/// <param name="def_printer"></param>
		private static void LoadPrinters()
		{
			installed_printers.Clear ();		
			if (cups_installed == false)
				return;
			
			IntPtr dests = IntPtr.Zero, ptr_printers;
			CUPS_DESTS printer;
		  	int n_printers = 0;
			int cups_dests_size = Marshal.SizeOf(typeof(CUPS_DESTS));
			string name, first, type, status, comment;
			first = type = status = comment = String.Empty;
			int state = 0;
			
			try {
				n_printers = OpenDests (ref dests);

				ptr_printers = dests;
				for (int i = 0; i < n_printers; i++) {
					printer = (CUPS_DESTS) Marshal.PtrToStructure (ptr_printers, typeof (CUPS_DESTS));
					name = Marshal.PtrToStringAnsi (printer.name);

					if (printer.is_default == 1)
						default_printer = name;
				
					if (first.Equals (String.Empty))
						first = name;
			
					NameValueCollection options = LoadPrinterOptions(printer.options, printer.num_options);
				
					if (options["printer-state"] != null)
						state = Int32.Parse(options["printer-state"]);
				
					if (options["printer-comment"] != null)
						comment = options["printer-state"];

					switch(state) {
						case 4:
							status = "Printing";
							break;
						case 5:
							status = "Stopped";
							break;
						default:
							status =  "Ready";
							break;
					}
				
					installed_printers.Add (name, new SysPrn.Printer (String.Empty, type, status, comment));

					ptr_printers = (IntPtr) ((long)ptr_printers + cups_dests_size);
				}
			
			}
			finally {
				CloseDests (ref dests, n_printers);
			}
			
			if (default_printer.Equals (String.Empty))
				default_printer = first;
		}

		/// <summary>
		/// Gets a printer's settings for use in the print dialogue
		/// </summary>
		/// <param name="printer"></param>
		/// <param name="port"></param>
		/// <param name="type"></param>
		/// <param name="status"></param>
		/// <param name="comment"></param>
		internal override void GetPrintDialogInfo (string printer, ref string port, ref string type, ref string status, ref string comment) {
			int count = 0, state = -1;
			bool found = false;
			CUPS_DESTS cups_dests;
			IntPtr dests = IntPtr.Zero, ptr_printers, ptr_printer;
			int cups_dests_size = Marshal.SizeOf(typeof(CUPS_DESTS));
			
			if (cups_installed == false)
				return;

			try {
				count = OpenDests (ref dests);

				if (count == 0)
					return;

				ptr_printers = dests;

				for (int i = 0; i < count; i++) {
					ptr_printer = (IntPtr) Marshal.ReadIntPtr (ptr_printers);
					if (Marshal.PtrToStringAnsi (ptr_printer).Equals(printer)) {
						found = true;
						break;
					}
					ptr_printers = (IntPtr) ((long)ptr_printers + cups_dests_size);				
				}
			
				if (!found)
					return;
			
				cups_dests = (CUPS_DESTS) Marshal.PtrToStructure (ptr_printers, typeof (CUPS_DESTS));
			
				NameValueCollection options = LoadPrinterOptions(cups_dests.options, cups_dests.num_options);

				if (options["printer-state"] != null)
					state = Int32.Parse(options["printer-state"]);
			
				if (options["printer-comment"] != null)
					comment = options["printer-state"];

				switch(state) {
					case 4:
						status = "Printing";
						break;
					case 5:
						status = "Stopped";
						break;
					default:
						status =  "Ready";
						break;
				}
			}
			finally {
				CloseDests (ref dests, count);
			}
		}

		/// <summary>
		/// Returns the appropriate PaperKind for the width and height
		/// </summary>
		/// <param name="width"></param>
		/// <param name="height"></param>
		private PaperKind GetPaperKind (int width, int height)
		{
			if (width == 827 && height == 1169)
				return PaperKind.A4;
			if (width == 583 && height == 827)
				return PaperKind.A5;
			if (width == 717 && height == 1012)
				return PaperKind.B5;
			if (width == 693 && height == 984)
				return PaperKind.B5Envelope;
			if (width == 638 && height == 902)
				return PaperKind.C5Envelope;
			if (width == 449 && height == 638)
				return PaperKind.C6Envelope;
			if (width == 1700 && height == 2200)
				return PaperKind.CSheet;
			if (width == 433 && height == 866)
				return PaperKind.DLEnvelope;
			if (width == 2200 && height == 3400)
				return PaperKind.DSheet;
			if (width == 3400 && height == 4400)
				return PaperKind.ESheet;
			if (width == 725 && height == 1050)
				return PaperKind.Executive;
			if (width == 850 && height == 1300)
				return PaperKind.Folio;
			if (width == 850 && height == 1200)
				return PaperKind.GermanStandardFanfold;
			if (width == 1700 && height == 1100)
				return PaperKind.Ledger;
			if (width == 850 && height == 1400)
				return PaperKind.Legal;
			if (width == 927 && height == 1500)
				return PaperKind.LegalExtra;
			if (width == 850 && height == 1100)
				return PaperKind.Letter;
			if (width == 927 && height == 1200)
				return PaperKind.LetterExtra;
			if (width == 850 && height == 1269)
				return PaperKind.LetterPlus;
			if (width == 387 && height == 750)
				return PaperKind.MonarchEnvelope;
			if (width == 387 && height == 887)
				return PaperKind.Number9Envelope;
			if (width == 413 && height == 950)
				return PaperKind.Number10Envelope;
			if (width == 450 && height == 1037)
				return PaperKind.Number11Envelope;
			if (width == 475 && height == 1100)
				return PaperKind.Number12Envelope;
			if (width == 500 && height == 1150)
				return PaperKind.Number14Envelope;
			if (width == 363 && height == 650)
				return PaperKind.PersonalEnvelope;
			if (width == 1000 && height == 1100)
				return PaperKind.Standard10x11;
			if (width == 1000 && height == 1400)
				return PaperKind.Standard10x14;
			if (width == 1100 && height == 1700)
				return PaperKind.Standard11x17;
			if (width == 1200 && height == 1100)
				return PaperKind.Standard12x11;
			if (width == 1500 && height == 1100)
				return PaperKind.Standard15x11;
			if (width == 900 && height == 1100)
				return PaperKind.Standard9x11;
			if (width == 550 && height == 850)
				return PaperKind.Statement;
			if (width == 1100 && height == 1700)
				return PaperKind.Tabloid;
			if (width == 1487 && height == 1100)
				return PaperKind.USStandardFanfold;

			return PaperKind.Custom;
		}

		#endregion

		#region Print job methods

		static string tmpfile;

		/// <summary>
		/// Gets a pointer to an options list parsed from the printer's current settings, to use when setting up the printing job
		/// </summary>
		/// <param name="printer_settings"></param>
		/// <param name="page_settings"></param>
		/// <param name="options"></param>
		internal static int GetCupsOptions (PrinterSettings printer_settings, PageSettings page_settings, out IntPtr options)
		{
			options = IntPtr.Zero;

			PaperSize size = page_settings.PaperSize;
			int width = size.Width * 72 / 100;
			int height = size.Height * 72 / 100;

			StringBuilder sb = new StringBuilder();
			sb.Append(
				"copies=" + printer_settings.Copies + " " + 
				"Collate=" + printer_settings.Collate + " " +
				"ColorModel=" + (page_settings.Color ? "Color" : "Black") + " " +
				"PageSize=" + String.Format ("Custom.{0}x{1}", width, height) + " " +
				"landscape=" + page_settings.Landscape
			);
			
			if (printer_settings.CanDuplex)
			{
				if (printer_settings.Duplex == Duplex.Simplex)
					sb.Append(" Duplex=None");
				else
					sb.Append(" Duplex=DuplexNoTumble");				
			}

			return cupsParseOptions (sb.ToString(), 0, ref options);
		}

		internal static bool StartDoc (GraphicsPrinter gr, string doc_name, string output_file)
		{
			DOCINFO doc = (DOCINFO) doc_info[gr.Hdc];
			doc.title = doc_name;
			return true;
		}

		internal static bool EndDoc (GraphicsPrinter gr)
		{
			DOCINFO doc = (DOCINFO) doc_info[gr.Hdc];

			gr.Graphics.Dispose (); // Dispose object to force surface finish
			
			IntPtr options;
			int options_count = GetCupsOptions (doc.settings, doc.default_page_settings, out options);

			cupsPrintFile (doc.settings.PrinterName, doc.filename, doc.title, options_count, options);
			cupsFreeOptions (options_count, options);
			doc_info.Remove (gr.Hdc);
			if (tmpfile != null) {
				try { File.Delete (tmpfile); }
				catch { }
			}
			return true;
		}

		internal static bool StartPage (GraphicsPrinter gr)
		{
			return true;
		}

		internal static bool EndPage (GraphicsPrinter gr)
		{
			GdipGetPostScriptSavePage (gr.Hdc);
			return true;
		}

		// Unfortunately, PrinterSettings and PageSettings couldn't be referencing each other,
		// thus we need to pass them separately
		internal static IntPtr CreateGraphicsContext (PrinterSettings settings, PageSettings default_page_settings)
		{
			IntPtr graphics = IntPtr.Zero;
			string name;
			if (!settings.PrintToFile) {
				StringBuilder sb = new StringBuilder (1024);
				int length = sb.Capacity;
				cupsTempFile (sb, length);
				name = sb.ToString ();
				tmpfile = name;
			}
			else
				name = settings.PrintFileName;

			PaperSize psize = default_page_settings.PaperSize;
			int width, height;
			if (default_page_settings.Landscape) { // Swap in case of landscape
				width = psize.Height;
				height = psize.Width;
			} else {
				width = psize.Width;
				height = psize.Height;
			}

			GdipGetPostScriptGraphicsContext (name,
				width * 72 / 100,
				height * 72 / 100, 
				default_page_settings.PrinterResolution.X,
				default_page_settings.PrinterResolution.Y, ref graphics);

			DOCINFO doc = new DOCINFO ();
			doc.filename = name;
			doc.settings = settings;
			doc.default_page_settings = default_page_settings;
			doc_info.Add (graphics, doc);

			return graphics;
		}

		#endregion

		#region DllImports

		[DllImport("libcups", CharSet=CharSet.Ansi)]
		static extern int cupsGetDests (ref IntPtr dests);

//		[DllImport("libcups", CharSet=CharSet.Ansi)]
//		static extern void cupsGetDest (string name, string instance, int num_dests, ref IntPtr dests);

		[DllImport("libcups")]
		static extern void cupsFreeDests (int num_dests, IntPtr dests);

		[DllImport("libcups", CharSet=CharSet.Ansi)]
		static extern IntPtr cupsTempFile (StringBuilder sb, int len);

		[DllImport("libcups", CharSet=CharSet.Ansi)]
		static extern IntPtr cupsGetDefault ();

		[DllImport("libcups", CharSet=CharSet.Ansi)]
		static extern int cupsPrintFile (string printer, string filename, string title, int num_options, IntPtr options);

		[DllImport("libcups", CharSet=CharSet.Ansi)]
		static extern IntPtr cupsGetPPD (string printer);

		[DllImport("libcups", CharSet=CharSet.Ansi)]
		static extern IntPtr ppdOpenFile (string filename);

		[DllImport("libcups", CharSet=CharSet.Ansi)]
		static extern IntPtr ppdFindOption (IntPtr ppd_file, string keyword);

		[DllImport("libcups")]
		static extern void ppdClose (IntPtr ppd);

		[DllImport ("libcups", CharSet=CharSet.Ansi)]
		static extern int cupsParseOptions (string arg, int number_of_options, ref IntPtr options);

		[DllImport("libcups")]
		static extern void cupsFreeOptions (int number_options, IntPtr options);

		[DllImport("gdiplus.dll", CharSet=CharSet.Ansi)]
		static extern int GdipGetPostScriptGraphicsContext (string filename, int with, int height, double dpix, double dpiy, ref IntPtr graphics);

		[DllImport("gdiplus.dll")]
		static extern int GdipGetPostScriptSavePage (IntPtr graphics);

		#endregion

		#region Struct
		public struct DOCINFO
		{
 			public PrinterSettings settings;
			public PageSettings default_page_settings;
			public string title;
			public string filename;
  		}

		public struct PPD_SIZE
		{
			public	int marked;
			[MarshalAs(UnmanagedType.ByValTStr, SizeConst=42)]
			public	string name;
			public  float width;
			public  float length;
			public	float left;
			public  float bottom;
			public	float right;
			public 	float top;
		}

		public struct PPD_GROUP
		{
			[MarshalAs(UnmanagedType.ByValTStr, SizeConst=40)]
			public string text;
  			[MarshalAs(UnmanagedType.ByValTStr, SizeConst=42)]
			public string name;
  			public int num_options;
			public IntPtr options;
 			public int num_subgroups;
			public IntPtr subgrups;
		}

		public struct PPD_OPTION
		{
			public byte 	conflicted;
			[MarshalAs(UnmanagedType.ByValTStr, SizeConst=41)]
			public string	keyword;
			[MarshalAs(UnmanagedType.ByValTStr, SizeConst=41)]
			public string 	defchoice;
			[MarshalAs(UnmanagedType.ByValTStr, SizeConst=81)]
			public string 	text;
			public int	ui;
  			public int 	section;
  			public float	order;
  			public int	num_choices;
  			public IntPtr	choices;
		}

		public struct PPD_CHOICE
		{
			public byte 	marked;
			[MarshalAs(UnmanagedType.ByValTStr, SizeConst=41)]
			public string	choice;
			[MarshalAs(UnmanagedType.ByValTStr, SizeConst=81)]
			public string 	text;
			public IntPtr	code;
			public IntPtr	option;
		}

		public struct PPD_FILE
		{
  			public int	language_level;
			public int	color_device;
			public int	variable_sizes;
			public int	accurate_screens;
			public int	contone_only;
			public int	landscape;
			public int	model_number;
			public int	manual_copies;
			public int	throughput;
  			public int	colorspace;
  			public IntPtr 	patches;
			public int	num_emulations;
  			public IntPtr	emulations;
			public IntPtr 	jcl_begin;
			public IntPtr 	jcl_ps;
			public IntPtr 	jcl_end;
			public IntPtr 	lang_encoding;
			public IntPtr 	lang_version;
			public IntPtr 	modelname;
			public IntPtr 	ttrasterizer;
			public IntPtr 	manufacturer;
			public IntPtr 	product;
			public IntPtr 	nickname;
			public IntPtr 	shortnickname;
  			public int	num_groups;
			public IntPtr	groups;
  			public int	num_sizes;
  			public IntPtr	sizes;

			/* There is more data after this that we are not using*/
		}


		public struct CUPS_OPTIONS
		{
		  	public IntPtr name;
		  	public IntPtr val;
		}
		
		public struct CUPS_DESTS
		{
			public IntPtr	name;
			public IntPtr	instance;
			public int 	is_default;
			public int	num_options;
			public IntPtr	options;
		}
		
		#endregion
	}

	class GlobalPrintingServicesUnix : GlobalPrintingServices
	{
		internal override PrinterSettings.StringCollection InstalledPrinters {
			get {
				return PrintingServicesUnix.InstalledPrinters;
			}
		}

		internal override IntPtr CreateGraphicsContext (PrinterSettings settings, PageSettings default_page_settings)
		{
			return PrintingServicesUnix.CreateGraphicsContext (settings, default_page_settings);
		}

		internal override bool StartDoc (GraphicsPrinter gr, string doc_name, string output_file)
		{
			return PrintingServicesUnix.StartDoc (gr, doc_name, output_file);
		}

		internal override bool EndDoc (GraphicsPrinter gr)
		{
			return PrintingServicesUnix.EndDoc (gr);
		}

		internal override bool StartPage (GraphicsPrinter gr)
		{
			return PrintingServicesUnix.StartPage (gr);
		}

		internal override bool EndPage (GraphicsPrinter gr)
		{
			return PrintingServicesUnix.EndPage (gr);
		}
	}
}