Merge the gtk-printing branch. For more detailed ChangeLog entries, see

2006-04-21  Alexander Larsson  <alexl@redhat.com>

        Merge the gtk-printing branch.
	For more detailed ChangeLog entries, see the branch.

	* .cvsignore:
	* Makefile.am:
	* configure.in:
	* docs/tools/widgets.c:
	* gtk+-unix-print-2.0.pc.in:
	* gtk/Makefile.am:
	* gtk/gen-paper-names.c:
	* gtk/gtk.h:
	* gtk/gtk.symbols:
	* gtk/gtkenums.h:
	* gtk/gtkiconfactory.c:
	* gtk/gtkmarshalers.list:
	* gtk/gtkpagesetup.[ch]:
	* gtk/gtkpagesetupunixdialog.[ch]:
	* gtk/gtkpapersize.[ch]:
	* gtk/gtkprint-win32.[ch]:
	* gtk/gtkprintbackend.[ch]:
	* gtk/gtkprintcontext.[ch]:
	* gtk/gtkprinter-private.h:
	* gtk/gtkprinter.[ch]:
	* gtk/gtkprinteroption.[ch]:
	* gtk/gtkprinteroptionset.[ch]:
	* gtk/gtkprinteroptionwidget.[ch]:
	* gtk/gtkprintjob.[ch]:
	* gtk/gtkprintoperation-private.h:
	* gtk/gtkprintoperation-unix.c:
	* gtk/gtkprintoperation-win32.c:
	* gtk/gtkprintoperation.[ch]:
	* gtk/gtkprintsettings.[ch]:
	* gtk/gtkprintunixdialog.[ch]:
	* gtk/paper_names.c:
	* gtk/paper_names_offsets.c:
	Platform independent printing API and implementations
	for unix and windows.

	* gtk/gtkstock.h:
	* gtk/stock-icons/24/gtk-orientation-landscape.png:
	* gtk/stock-icons/24/gtk-orientation-portrait.png:
	* gtk/stock-icons/24/gtk-orientation-reverse-landscape.png:
	Add stock icons for page orientation.

	* modules/Makefile.am:
	* modules/printbackends/Makefile.am:
	* modules/printbackends/cups/Makefile.am:
	* modules/printbackends/cups/gtkcupsutils.[ch]:
	* modules/printbackends/cups/gtkprintbackendcups.[ch]:
	* modules/printbackends/cups/gtkprintercups.[ch]:

	Cups printing backend for unix.

	* modules/printbackends/lpr/Makefile.am:
	* modules/printbackends/lpr/gtkprintbackendlpr.[ch]:
	lpr printing backend for unix.

	* modules/printbackends/pdf/Makefile.am:
	* modules/printbackends/pdf/gtkprintbackendpdf.[ch]:
	print-to-pdf printing backend for unix.

	* tests/.cvsignore:
	* tests/Makefile.am:
	* tests/print-editor.c:
	Test application for printing.

	* gdk/gdk.symbols:
	* gdk/win32/gdkevents-win32.c:
	* gdk/win32/gdkwin32.h:
	Add gdk_win32_set_modal_dialog_libgtk_only so that we can pump the
	mainloop while displaying a win32 common dialog.

	* gdk/directfb/Makefile.am:
	Whitespace cleanup.

1 files changed, 1230 insertions, 0 deletions

diff --git a/gtk/gtkprintsettings.c b/gtk/gtkprintsettings.c
new file mode 100644
index 0000000000..80c0c9913b
--- /dev/null
+++ b/gtk/gtkprintsettings.c
@@ -0,0 +1,1230 @@
+/* GTK - The GIMP Toolkit
+ * gtkprintsettings.c: Print Settings
+ * Copyright (C) 2006, Red Hat, Inc.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+
+#include "config.h"
+#include <string.h>
+#include <stdlib.h>
+#include <glib/gprintf.h>
+#include "gtkprintsettings.h"
+#include "gtkalias.h"
+
+#define MM_PER_INCH 25.4
+#define POINTS_PER_INCH 72
+
+typedef struct _GtkPrintSettingsClass GtkPrintSettingsClass;
+
+#define GTK_IS_PRINT_SETTINGS_CLASS(klass)  (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_PRINT_SETTINGS))
+#define GTK_PRINT_SETTINGS_CLASS(klass)     (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_PRINT_SETTINGS, GtkPrintSettingsClass))
+#define GTK_PRINT_SETTINGS_GET_CLASS(obj)   (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_PRINT_SETTINGS, GtkPrintSettingsClass))
+
+struct _GtkPrintSettings
+{
+  GObject parent_instance;
+  
+  GHashTable *hash;
+};
+
+struct _GtkPrintSettingsClass
+{
+  GObjectClass parent_class;
+};
+
+G_DEFINE_TYPE (GtkPrintSettings, gtk_print_settings, G_TYPE_OBJECT)
+
+static gdouble
+to_mm (gdouble len, GtkUnit unit)
+{
+  switch (unit)
+    {
+    case GTK_UNIT_MM:
+      return len;
+    case GTK_UNIT_INCH:
+      return len * MM_PER_INCH;
+    default:
+    case GTK_UNIT_PIXEL:
+      g_warning ("Unsupported unit");
+      /* Fall through */
+    case GTK_UNIT_POINTS:
+      return len * (MM_PER_INCH / POINTS_PER_INCH);
+      break;
+    }
+}
+
+static gdouble
+from_mm (gdouble len, GtkUnit unit)
+{
+  switch (unit)
+    {
+    case GTK_UNIT_MM:
+      return len;
+    case GTK_UNIT_INCH:
+      return len / MM_PER_INCH;
+    default:
+    case GTK_UNIT_PIXEL:
+      g_warning ("Unsupported unit");
+      /* Fall through */
+    case GTK_UNIT_POINTS:
+      return len / (MM_PER_INCH / POINTS_PER_INCH);
+      break;
+    }
+}
+
+static void
+gtk_print_settings_finalize (GObject *object)
+{
+  GtkPrintSettings *settings = GTK_PRINT_SETTINGS (object);
+
+  g_hash_table_destroy (settings->hash);
+
+  G_OBJECT_CLASS (gtk_print_settings_parent_class)->finalize (object);
+}
+
+static void
+gtk_print_settings_init (GtkPrintSettings *settings)
+{
+  settings->hash = g_hash_table_new_full (g_str_hash, g_str_equal,
+					  g_free, g_free);
+}
+
+static void
+gtk_print_settings_class_init (GtkPrintSettingsClass *class)
+{
+  GObjectClass *gobject_class = (GObjectClass *)class;
+
+  gobject_class->finalize = gtk_print_settings_finalize;
+}
+
+/**
+ * gtk_print_settings_new:
+ * 
+ * Creates a new #GtkPrintSettings object.
+ *  
+ * Return value: a new #GtkPrintSettings object
+ *
+ * Since: 2.10
+ */
+GtkPrintSettings *
+gtk_print_settings_new (void)
+{
+  return g_object_new (GTK_TYPE_PRINT_SETTINGS, NULL);
+}
+
+static void
+copy_hash_entry  (gpointer  key,
+		  gpointer  value,
+		  gpointer  user_data)
+{
+  GtkPrintSettings *settings = user_data;
+
+  g_hash_table_insert (settings->hash, 
+		       g_strdup (key), 
+		       g_strdup (value));
+}
+
+
+
+/**
+ * gtk_print_settings_copy:
+ * @other: a #GtkPrintSettings
+ * 
+ * Copies a #GtkPrintSettings object.
+ * 
+ * Return value: a newly allocated copy of @other
+ *
+ * Since: 2.10
+ */
+GtkPrintSettings *
+gtk_print_settings_copy (GtkPrintSettings *other)
+{
+  GtkPrintSettings *settings;
+
+  if (other == NULL)
+    return NULL;
+  
+  g_return_val_if_fail (GTK_IS_PRINT_SETTINGS (other), NULL);
+
+  settings = gtk_print_settings_new ();
+
+  g_hash_table_foreach (other->hash,
+			copy_hash_entry,
+			settings);
+
+  return settings;
+}
+
+/**
+ * gtk_print_settings_get:
+ * @settings: a #GtkPrintSettings
+ * @key: a key
+ * 
+ * Looks up the string value associated with @key.
+ * 
+ * Return value: the string value for @key
+ * 
+ * Since: 2.10
+ */
+G_CONST_RETURN gchar *        
+gtk_print_settings_get (GtkPrintSettings *settings,
+			const gchar      *key)
+{
+  return g_hash_table_lookup (settings->hash, key);
+}
+
+/**
+ * gtk_print_settings_set:
+ * @settings: a #GtkPrintSettings
+ * @key: a key
+ * @value: a string value, or %NULL
+ * 
+ * Associates @value with @key.
+ *
+ * Since: 2.10 
+ */
+void
+gtk_print_settings_set (GtkPrintSettings *settings,
+			const gchar      *key,
+			const gchar      *value)
+{
+  if (value == NULL)
+    gtk_print_settings_unset (settings, key);
+  else
+    g_hash_table_insert (settings->hash, 
+			 g_strdup (key), 
+			 g_strdup (value));
+}
+
+/**
+ * gtk_print_settings_unset:
+ * @settings: a #GtkPrintSettings
+ * @key: a key
+ * 
+ * Removes any value associated with @key. 
+ * This has the same effect as setting the value to %NULL.
+ *
+ * Since: 2.10 
+ */
+void
+gtk_print_settings_unset (GtkPrintSettings *settings,
+			  const gchar      *key)
+{
+  g_hash_table_remove (settings->hash, key);
+}
+
+/**
+ * gtk_print_settings_has_key:
+ * @settings: a #GtkPrintSettings
+ * @key: a key
+ * 
+ * Returns %TRUE, if a value is associated with @key.
+ * 
+ * Return value: %TRUE, if @key has a value
+ *
+ * Since: 2.10
+ */
+gboolean        
+gtk_print_settings_has_key (GtkPrintSettings *settings,
+			    const gchar      *key)
+{
+  return gtk_print_settings_get (settings, key) != NULL;
+}
+
+
+/**
+ * gtk_print_settings_get_bool:
+ * @settings: a #GtkPrintSettings
+ * @key: a key
+ * 
+ * Returns the boolean represented by the value
+ * that is associated with @key. 
+ *
+ * The string "true" represents %TRUE, any other 
+ * string %FALSE.
+ *
+ * Return value: %TRUE, if @key maps to a true value.
+ * 
+ * Since: 2.10
+ **/
+gboolean
+gtk_print_settings_get_bool (GtkPrintSettings *settings,
+			     const gchar      *key)
+{
+  const gchar *val;
+
+  val = gtk_print_settings_get (settings, key);
+  if (val != NULL && strcmp (val, "true") == 0)
+    return TRUE;
+  
+  return FALSE;
+}
+
+/**
+ * gtk_print_settings_get_bool_with_default:
+ * @settings: a #GtkPrintSettings
+ * @key: a key
+ * @default_val: the default value
+ * 
+ * Returns the boolean represented by the value
+ * that is associated with @key, or @default_val
+ * if the value does not represent a boolean.
+ *
+ * The string "true" represents %TRUE, the string
+ * "false" represents %FALSE.
+ *
+ * Return value: the boolean value associated with @key
+ * 
+ * Since: 2.10
+ */
+static gboolean
+gtk_print_settings_get_bool_with_default (GtkPrintSettings *settings,
+					  const gchar      *key,
+					  gboolean          default_val)
+{
+  const gchar *val;
+
+  val = gtk_print_settings_get (settings, key);
+  if (val != NULL && strcmp (val, "true") == 0)
+    return TRUE;
+
+  if (val != NULL && strcmp (val, "false") == 0)
+    return FALSE;
+  
+  return default_val;
+}
+
+/**
+ * gtk_print_settings_set_bool:
+ * @settings: a #GtkPrintSettings
+ * @key: a key
+ * @value: a boolean
+ * 
+ * Sets @key to a boolean value.
+ *
+ * Since: 2.10
+ */
+void
+gtk_print_settings_set_bool (GtkPrintSettings *settings,
+			     const gchar      *key,
+			     gboolean          value)
+{
+  if (value)
+    gtk_print_settings_set (settings, key, "true");
+  else
+    gtk_print_settings_set (settings, key, "false");
+}
+
+/**
+ * gtk_print_settings_get_double_with_default:
+ * @settings: a #GtkPrintSettings
+ * @key: a key
+ * @def: the default value
+ * 
+ * Returns the floating point number represented by 
+ * the value that is associated with @key, or @default_val
+ * if the value does not represent a floating point number.
+ *
+ * Floating point numbers are parsed with g_ascii_strtod().
+ *
+ * Return value: the floating point number associated with @key
+ * 
+ * Since: 2.10
+ */
+gdouble
+gtk_print_settings_get_double_with_default (GtkPrintSettings *settings,
+					    const gchar      *key,
+					    gdouble           def)
+{
+  const gchar *val;
+
+  val = gtk_print_settings_get (settings, key);
+  if (val == NULL)
+    return def;
+
+  return g_ascii_strtod (val, NULL);
+}
+
+/**
+ * gtk_print_settings_get_double:
+ * @settings: a #GtkPrintSettings
+ * @key: a key
+ * 
+ * Returns the double value associated with @key, or 0.
+ * 
+ * Return value: the double value of @key
+ *
+ * Since: 2.10
+ */
+gdouble
+gtk_print_settings_get_double (GtkPrintSettings *settings,
+			       const gchar      *key)
+{
+  return gtk_print_settings_get_double_with_default (settings, key, 0.0);
+}
+
+/**
+ * gtk_print_settings_set_double:
+ * @settings: a #GtkPrintSettings
+ * @key: a key 
+ * @value: a double value
+ * 
+ * Sets @key to a double value.
+ * 
+ * Since: 2.10
+ */
+void
+gtk_print_settings_set_double (GtkPrintSettings *settings,
+			       const gchar      *key,
+			       gdouble           value)
+{
+  gchar buf[G_ASCII_DTOSTR_BUF_SIZE];
+  
+  g_ascii_dtostr (buf, G_ASCII_DTOSTR_BUF_SIZE, value);
+  gtk_print_settings_set (settings, key, buf);
+}
+
+/**
+ * gtk_print_settings_get_length:
+ * @settings: a #GtkPrintSettings
+ * @key: a key
+ * @unit: the unit of the return value
+ * 
+ * Returns the value associated with @key, interpreted
+ * as a length. The returned value is converted to @units.
+ * 
+ * Return value: the length value of @key, converted to @unit
+ *
+ * Since: 2.10
+ */
+gdouble
+gtk_print_settings_get_length (GtkPrintSettings *settings,
+			       const gchar      *key,
+			       GtkUnit           unit)
+{
+  gdouble length = gtk_print_settings_get_double (settings, key);
+  return from_mm (length, unit);
+}
+
+/**
+ * gtk_print_settings_set_length:
+ * @settings: a #GtkPrintSettings
+ * @key: a key
+ * @length: a length
+ * @unit: the unit of @length
+ * 
+ * Associates a length in units of @unit with @key.
+ *
+ * Since: 2.10
+ */
+void
+gtk_print_settings_set_length (GtkPrintSettings *settings,
+			       const gchar      *key,
+			       gdouble           length, 
+			       GtkUnit           unit)
+{
+  gtk_print_settings_set_double (settings, key,
+				 to_mm (length, unit));
+}
+
+/**
+ * gtk_print_settings_get_int_with_default:
+ * @settings: a #GtkPrintSettings
+ * @key: a key
+ * @def: the default value
+ * 
+ * Returns the value of @key, interpreted as
+ * an integer, or the default value.
+ * 
+ * Return value: the integer value of @key
+ *
+ * Since: 2.10
+ */
+gint
+gtk_print_settings_get_int_with_default (GtkPrintSettings *settings,
+					 const gchar      *key,
+					 gint              def)
+{
+  const gchar *val;
+
+  val = gtk_print_settings_get (settings, key);
+  if (val == NULL)
+    return def;
+
+  return atoi (val);
+}
+
+/**
+ * gtk_print_settings_get_int:
+ * @settings: a #GtkPrintSettings
+ * @key: a key
+ * 
+ * Returns the integer value of @key, or 0.
+ * 
+ * Return value: the integer value of @key 
+ *
+ * Since: 2.10
+ */
+gint
+gtk_print_settings_get_int (GtkPrintSettings *settings,
+			    const gchar      *key)
+{
+  return gtk_print_settings_get_int_with_default (settings, key, 0);
+}
+
+/**
+ * gtk_print_settings_set_int:
+ * @settings: a #GtkPrintSettings
+ * @key: a key
+ * @value: an integer 
+ * 
+ * Sets @key to an integer value.
+ *
+ * Since: 2.10 
+ */
+void
+gtk_print_settings_set_int (GtkPrintSettings *settings,
+			    const gchar      *key,
+			    gint              value)
+{
+  gchar buf[128];
+  g_sprintf (buf, "%d", value);
+  gtk_print_settings_set (settings, key, buf);
+}
+
+/**
+ * gtk_print_settings_foreach:
+ * @settings: a #GtkPrintSettings
+ * @func: the function to call
+ * @user_data: user data for @func
+ * 
+ * Calls @func for each key-value pair of @settings.
+ *
+ * Since: 2.10
+ */
+void
+gtk_print_settings_foreach (GtkPrintSettings    *settings,
+			    GtkPrintSettingsFunc func,
+			    gpointer             user_data)
+{
+  g_hash_table_foreach (settings->hash, (GHFunc)func, user_data);
+}
+
+/**
+ * gtk_print_settings_get_printer:
+ * @settings: a #GtkPrintSettings
+ * 
+ * Convenience function to obtain the value of 
+ * %GTK_PRINT_SETTINGS_PRINTER.
+ *
+ * Return value: the printer name
+ *
+ * Since: 2.10
+ */
+G_CONST_RETURN gchar *       
+gtk_print_settings_get_printer (GtkPrintSettings *settings)
+{
+  return gtk_print_settings_get (settings, GTK_PRINT_SETTINGS_PRINTER);
+}
+
+
+/**
+ * gtk_print_settings_set_printer:
+ * @settings: a #GtkPrintSettings
+ * @printer: the printer name
+ * 
+ * Convenience function to set %GTK_PRINT_SETTINGS_PRINTER
+ * to @printer.
+ *
+ * Since: 2.10
+ */
+void
+gtk_print_settings_set_printer (GtkPrintSettings *settings,
+				const gchar      *printer)
+{
+  gtk_print_settings_set (settings, GTK_PRINT_SETTINGS_PRINTER, printer);
+}
+
+/**
+ * gtk_print_settings_get_orientation:
+ * @settings: a #GtkPrintSettings
+ * 
+ * Get the value of %GTK_PRINT_SETTINGS_ORIENTATION, 
+ * converted to a #GtkPageOrientation.
+ * 
+ * Return value: the orientation
+ *
+ * Since: 2.10
+ */
+GtkPageOrientation
+gtk_print_settings_get_orientation (GtkPrintSettings *settings)
+{
+  const gchar *val;
+
+  val = gtk_print_settings_get (settings, GTK_PRINT_SETTINGS_ORIENTATION);
+
+  if (val == NULL || strcmp (val, "portrait") == 0)
+    return GTK_PAGE_ORIENTATION_PORTRAIT;
+
+  if (strcmp (val, "landscape") == 0)
+    return GTK_PAGE_ORIENTATION_LANDSCAPE;
+  
+  if (strcmp (val, "reverse_portrait") == 0)
+    return GTK_PAGE_ORIENTATION_REVERSE_PORTRAIT;
+  
+  if (strcmp (val, "reverse_landscape") == 0)
+    return GTK_PAGE_ORIENTATION_REVERSE_LANDSCAPE;
+  
+  return GTK_PAGE_ORIENTATION_PORTRAIT;
+}
+
+/**
+ * gtk_print_settings_set_orientation:
+ * @settings: a #GtkPrintSettings
+ * @orientation: a page orientation
+ * 
+ * Sets the value of %GTK_PRINT_SETTINGS_ORIENTATION.
+ * 
+ * Since: 2.10
+ */
+void
+gtk_print_settings_set_orientation (GtkPrintSettings   *settings,
+				    GtkPageOrientation  orientation)
+{
+  const gchar *val;
+
+  switch (orientation)
+    {
+    case GTK_PAGE_ORIENTATION_LANDSCAPE:
+      val = "landscape";
+      break;
+    default:
+    case GTK_PAGE_ORIENTATION_PORTRAIT:
+      val = "portrait";
+      break;
+    case GTK_PAGE_ORIENTATION_REVERSE_LANDSCAPE:
+      val = "reverse_landscape";
+      break;
+    case GTK_PAGE_ORIENTATION_REVERSE_PORTRAIT:
+      val = "reverse_portrait";
+      break;
+    }
+  gtk_print_settings_set (settings, GTK_PRINT_SETTINGS_ORIENTATION, val);
+}
+
+/**
+ * gtk_print_settings_get_paper_size:
+ * @settings: a #GtkPrintSettings
+ * 
+ * Gets the value of %GTK_PRINT_SETTINGS_PAPER_FORMAT, 
+ * converted to a #GtkPaperSize.
+ * 
+ * Return value: the paper size
+ *
+ * Since: 2.10
+ */
+GtkPaperSize *     
+gtk_print_settings_get_paper_size (GtkPrintSettings *settings)
+{
+  const gchar *val;
+  const gchar *name;
+  gdouble w, h;
+
+  val = gtk_print_settings_get (settings, GTK_PRINT_SETTINGS_PAPER_FORMAT);
+  if (val == NULL)
+    return NULL;
+
+  if (g_str_has_prefix (val, "custom-")) 
+    {
+      name = val + strlen ("custom-");
+      w = gtk_print_settings_get_paper_width (settings, GTK_UNIT_MM);
+      h = gtk_print_settings_get_paper_height (settings, GTK_UNIT_MM);
+      return gtk_paper_size_new_custom (name, name, w, h, GTK_UNIT_MM);
+    }
+
+  return gtk_paper_size_new (val);
+}
+
+/**
+ * gtk_print_settings_set_paper_size:
+ * @settings: a #GtkPrintSettings
+ * @paper_size: a paper size
+ * 
+ * Sets the value of %GTK_PRINT_SETTINGS_PAPER_FORMAT,
+ * %GTK_PRINT_SETTINGS_PAPER_WIDTH and
+ * %GTK_PRINT_SETTINGS_PAPER_HEIGHT.
+ *
+ * Since: 2.10
+ */
+void
+gtk_print_settings_set_paper_size (GtkPrintSettings *settings,
+				   GtkPaperSize     *paper_size)
+{
+  gchar *custom_name;
+
+  if (paper_size == NULL) 
+    {
+      gtk_print_settings_set (settings, GTK_PRINT_SETTINGS_PAPER_FORMAT, NULL);
+      gtk_print_settings_set (settings, GTK_PRINT_SETTINGS_PAPER_WIDTH, NULL);
+      gtk_print_settings_set (settings, GTK_PRINT_SETTINGS_PAPER_HEIGHT, NULL);
+    }
+  else if (gtk_paper_size_is_custom (paper_size)) 
+    {
+      custom_name = g_strdup_printf ("custom-%s", 
+				     gtk_paper_size_get_name (paper_size));
+      gtk_print_settings_set (settings, GTK_PRINT_SETTINGS_PAPER_FORMAT, custom_name);
+      g_free (custom_name);
+      gtk_print_settings_set_paper_width (settings, 
+					  gtk_paper_size_get_width (paper_size, 
+								    GTK_UNIT_MM),
+					  GTK_UNIT_MM);
+      gtk_print_settings_set_paper_height (settings, 
+					   gtk_paper_size_get_height (paper_size, 
+								      GTK_UNIT_MM),
+					   GTK_UNIT_MM);
+    } 
+  else
+    gtk_print_settings_set (settings, GTK_PRINT_SETTINGS_PAPER_FORMAT, 
+			    gtk_paper_size_get_name (paper_size));
+}
+
+/**
+ * gtk_print_settings_get_paper_width:
+ * @settings: a #GtkPrintSettings
+ * @unit: the unit for the return value
+ * 
+ * Gets the value of %GTK_PRINT_SETTINGS_PAPER_WIDTH,
+ * converted to @unit. 
+ * 
+ * Return value: the paper width, in units of @unit
+ *
+ * Since: 2.10
+ */
+gdouble
+gtk_print_settings_get_paper_width (GtkPrintSettings *settings,
+				    GtkUnit           unit)
+{
+  return gtk_print_settings_get_length (settings, GTK_PRINT_SETTINGS_PAPER_WIDTH, unit);
+}
+
+/**
+ * gtk_print_settings_set_paper_width:
+ * @settings: a #GtkPrintSettings
+ * @width: the paper width
+ * @unit: the units of @width
+ * 
+ * Sets the value of %GTK_PRINT_SETTINGS_PAPER_WIDTH.
+ *
+ * Since: 2.10
+ */
+void
+gtk_print_settings_set_paper_width (GtkPrintSettings *settings,
+				    gdouble           width, 
+				    GtkUnit           unit)
+{
+  gtk_print_settings_set_length (settings, GTK_PRINT_SETTINGS_PAPER_WIDTH, width, unit);
+}
+
+/**
+ * gtk_print_settings_get_paper_height:
+ * @settings: a #GtkPrintSettings
+ * @unit: the unit for the return value
+ * 
+ * Gets the value of %GTK_PRINT_SETTINGS_PAPER_HEIGHT,
+ * converted to @unit. 
+ * 
+ * Return value: the paper height, in units of @unit
+ *
+ * Since: 2.10
+ */
+gdouble
+gtk_print_settings_get_paper_height (GtkPrintSettings *settings,
+				     GtkUnit           unit)
+{
+  return gtk_print_settings_get_length (settings, 
+					GTK_PRINT_SETTINGS_PAPER_HEIGHT,
+					unit);
+}
+
+/**
+ * gtk_print_settings_set_paper_height:
+ * @settings: a #GtkPrintSettings
+ * @height: the paper height
+ * @unit: the units of @height
+ * 
+ * Sets the value of %GTK_PRINT_SETTINGS_PAPER_HEIGHT.
+ *
+ * Since: 2.10
+ */
+void
+gtk_print_settings_set_paper_height (GtkPrintSettings *settings,
+				     gdouble           height, 
+				     GtkUnit           unit)
+{
+  gtk_print_settings_set_length (settings, 
+				 GTK_PRINT_SETTINGS_PAPER_HEIGHT, 
+				 height, unit);
+}
+
+gboolean
+gtk_print_settings_get_use_color (GtkPrintSettings *settings)
+{
+  return gtk_print_settings_get_bool_with_default (settings, 
+						   GTK_PRINT_SETTINGS_USE_COLOR,
+						   TRUE);
+}
+
+void
+gtk_print_settings_set_use_color (GtkPrintSettings *settings,
+				  gboolean          use_color)
+{
+  gtk_print_settings_set_bool (settings,
+			       GTK_PRINT_SETTINGS_USE_COLOR, 
+			       use_color);
+}
+
+gboolean
+gtk_print_settings_get_collate (GtkPrintSettings *settings)
+{
+  return gtk_print_settings_get_bool (settings, 
+				      GTK_PRINT_SETTINGS_COLLATE);
+}
+
+void
+gtk_print_settings_set_collate (GtkPrintSettings *settings,
+				gboolean          collate)
+{
+  gtk_print_settings_set_bool (settings,
+			       GTK_PRINT_SETTINGS_COLLATE, 
+			       collate);
+}
+
+gboolean
+gtk_print_settings_get_reverse (GtkPrintSettings *settings)
+{
+  return gtk_print_settings_get_bool (settings, 
+				      GTK_PRINT_SETTINGS_REVERSE);
+}
+
+void
+gtk_print_settings_set_reverse (GtkPrintSettings *settings,
+				  gboolean        reverse)
+{
+  gtk_print_settings_set_bool (settings,
+			       GTK_PRINT_SETTINGS_REVERSE, 
+			       reverse);
+}
+
+GtkPrintDuplex
+gtk_print_settings_get_duplex (GtkPrintSettings *settings)
+{
+  const gchar *val;
+
+  val = gtk_print_settings_get (settings, GTK_PRINT_SETTINGS_DUPLEX);
+
+  if (val == NULL || (strcmp (val, "simplex") == 0))
+    return GTK_PRINT_DUPLEX_SIMPLEX;
+
+  if (strcmp (val, "horizontal") == 0)
+    return GTK_PRINT_DUPLEX_HORIZONTAL;
+  
+  if (strcmp (val, "vertical") == 0)
+    return GTK_PRINT_DUPLEX_HORIZONTAL;
+  
+  return GTK_PRINT_DUPLEX_SIMPLEX;
+}
+
+void
+gtk_print_settings_set_duplex (GtkPrintSettings *settings,
+			       GtkPrintDuplex    duplex)
+{
+  const gchar *str;
+
+  switch (duplex)
+    {
+    default:
+    case GTK_PRINT_DUPLEX_SIMPLEX:
+      str = "simplex";
+      break;
+    case GTK_PRINT_DUPLEX_HORIZONTAL:
+      str = "horizontal";
+      break;
+    case GTK_PRINT_DUPLEX_VERTICAL:
+      str = "vertical";
+      break;
+    }
+  
+  gtk_print_settings_set (settings, GTK_PRINT_SETTINGS_DUPLEX, str);
+}
+
+GtkPrintQuality
+gtk_print_settings_get_quality (GtkPrintSettings *settings)
+{
+  const gchar *val;
+
+  val = gtk_print_settings_get (settings, GTK_PRINT_SETTINGS_QUALITY);
+
+  if (val == NULL || (strcmp (val, "normal") == 0))
+    return GTK_PRINT_QUALITY_NORMAL;
+
+  if (strcmp (val, "high") == 0)
+    return GTK_PRINT_QUALITY_HIGH;
+  
+  if (strcmp (val, "low") == 0)
+    return GTK_PRINT_QUALITY_LOW;
+  
+  if (strcmp (val, "draft") == 0)
+    return GTK_PRINT_QUALITY_DRAFT;
+  
+  return GTK_PRINT_QUALITY_NORMAL;
+}
+
+void
+gtk_print_settings_set_quality (GtkPrintSettings *settings,
+				GtkPrintQuality   quality)
+{
+  const gchar *str;
+
+  switch (quality)
+    {
+    default:
+    case GTK_PRINT_QUALITY_NORMAL:
+      str = "normal";
+      break;
+    case GTK_PRINT_QUALITY_HIGH:
+      str = "high";
+      break;
+    case GTK_PRINT_QUALITY_LOW:
+      str = "low";
+      break;
+    case GTK_PRINT_QUALITY_DRAFT:
+      str = "draft";
+      break;
+    }
+  
+  gtk_print_settings_set (settings, GTK_PRINT_SETTINGS_QUALITY, str);
+}
+
+GtkPageSet
+gtk_print_settings_get_page_set (GtkPrintSettings *settings)
+{
+  const gchar *val;
+
+  val = gtk_print_settings_get (settings, GTK_PRINT_SETTINGS_PAGE_SET);
+
+  if (val == NULL || (strcmp (val, "all") == 0))
+    return GTK_PAGE_SET_ALL;
+
+  if (strcmp (val, "even") == 0)
+    return GTK_PAGE_SET_EVEN;
+  
+  if (strcmp (val, "odd") == 0)
+    return GTK_PAGE_SET_ODD;
+  
+  return GTK_PAGE_SET_ALL;
+}
+
+void
+gtk_print_settings_set_page_set (GtkPrintSettings *settings,
+				 GtkPageSet        page_set)
+{
+  const gchar *str;
+
+  switch (page_set)
+    {
+    default:
+    case GTK_PAGE_SET_ALL:
+      str = "all";
+      break;
+    case GTK_PAGE_SET_EVEN:
+      str = "even";
+      break;
+    case GTK_PAGE_SET_ODD:
+      str = "odd";
+      break;
+    }
+  
+  gtk_print_settings_set (settings, GTK_PRINT_SETTINGS_PAGE_SET, str);
+}
+
+gint
+gtk_print_settings_get_num_copies (GtkPrintSettings *settings)
+{
+  return gtk_print_settings_get_int_with_default (settings, GTK_PRINT_SETTINGS_NUM_COPIES, 1);
+}
+
+void
+gtk_print_settings_set_num_copies (GtkPrintSettings *settings,
+				   gint              num_copies)
+{
+  gtk_print_settings_set_int (settings, GTK_PRINT_SETTINGS_NUM_COPIES,
+			      num_copies);
+}
+
+gint
+gtk_print_settings_get_number_up (GtkPrintSettings *settings)
+{
+  return gtk_print_settings_get_int (settings, GTK_PRINT_SETTINGS_NUMBER_UP);
+}
+
+void
+gtk_print_settings_set_number_up (GtkPrintSettings *settings,
+				  gint              number_up)
+{
+  gtk_print_settings_set_int (settings, GTK_PRINT_SETTINGS_NUMBER_UP,
+				number_up);
+}
+
+gint
+gtk_print_settings_get_resolution (GtkPrintSettings *settings)
+{
+  return gtk_print_settings_get_int (settings, GTK_PRINT_SETTINGS_RESOLUTION);
+}
+
+void
+gtk_print_settings_set_resolution (GtkPrintSettings *settings,
+				   gint              resolution)
+{
+  gtk_print_settings_set_int (settings, GTK_PRINT_SETTINGS_RESOLUTION,
+			      resolution);
+}
+
+gdouble
+gtk_print_settings_get_scale (GtkPrintSettings *settings)
+{
+  return gtk_print_settings_get_double_with_default (settings,
+						     GTK_PRINT_SETTINGS_SCALE,
+						     100.0);
+}
+
+void
+gtk_print_settings_set_scale (GtkPrintSettings *settings,
+			      gdouble           scale)
+{
+  gtk_print_settings_set_double (settings, GTK_PRINT_SETTINGS_SCALE,
+				 scale);
+}
+
+gboolean
+gtk_print_settings_get_print_to_file (GtkPrintSettings *settings)
+{
+  return gtk_print_settings_get_bool (settings, 
+				      GTK_PRINT_SETTINGS_PRINT_TO_FILE);
+}
+
+void
+gtk_print_settings_set_print_to_file (GtkPrintSettings *settings,
+				      gboolean          print_to_file)
+{
+  gtk_print_settings_set_bool (settings,
+			       GTK_PRINT_SETTINGS_PRINT_TO_FILE, 
+			       print_to_file);
+}
+
+GtkPrintPages
+gtk_print_settings_get_print_pages (GtkPrintSettings *settings)
+{
+  const gchar *val;
+
+  val = gtk_print_settings_get (settings, GTK_PRINT_SETTINGS_PRINT_PAGES);
+
+  if (val == NULL || (strcmp (val, "all") == 0))
+    return GTK_PRINT_PAGES_ALL;
+
+  if (strcmp (val, "current") == 0)
+    return GTK_PRINT_PAGES_CURRENT;
+  
+  if (strcmp (val, "ranges") == 0)
+    return GTK_PRINT_PAGES_RANGES;
+  
+  return GTK_PRINT_PAGES_ALL;
+}
+
+void
+gtk_print_settings_set_print_pages (GtkPrintSettings *settings,
+				    GtkPrintPages     print_pages)
+{
+  const gchar *str;
+
+  switch (print_pages)
+    {
+    default:
+    case GTK_PRINT_PAGES_ALL:
+      str = "all";
+      break;
+    case GTK_PRINT_PAGES_CURRENT:
+      str = "current";
+      break;
+    case GTK_PRINT_PAGES_RANGES:
+      str = "ranges";
+      break;
+    }
+  
+  gtk_print_settings_set (settings, GTK_PRINT_SETTINGS_PRINT_PAGES, str);
+}
+     
+
+
+GtkPageRange *
+gtk_print_settings_get_page_ranges (GtkPrintSettings *settings,
+				    gint             *num_ranges)
+{
+  const gchar *val;
+  gchar **range_strs;
+  GtkPageRange *ranges;
+  gint i, n;
+  
+  val = gtk_print_settings_get (settings, GTK_PRINT_SETTINGS_PAGE_RANGES);
+
+  if (val == NULL)
+    {
+      *num_ranges = 0;
+      return NULL;
+    }
+  
+  range_strs = g_strsplit (val, ",", 0);
+
+  for (i = 0; range_strs[i] != NULL; i++)
+    ;
+
+  n = i;
+
+  ranges = g_new0 (GtkPageRange, n);
+
+  for (i = 0; i < n; i++)
+    {
+      gint start, end;
+      gchar *str;
+
+      start = (gint)strtol (range_strs[i], &str, 10);
+      end = start;
+
+      if (*str == '-')
+	{
+	  str++;
+	  end = (gint)strtol (str, NULL, 10);
+	  if (end < start)
+	    end = start;
+	}
+
+      ranges[i].start = start;
+      ranges[i].end = end;
+    }
+
+  *num_ranges = n;
+  return ranges;
+}
+
+void
+gtk_print_settings_set_page_ranges  (GtkPrintSettings *settings,
+				     GtkPageRange     *page_ranges,
+				     gint              num_ranges)
+{
+  GString *s;
+  gint i;
+  
+  s = g_string_new ("");
+
+  for (i = 0; i < num_ranges; i++)
+    {
+      if (page_ranges[i].start == page_ranges[i].end)
+	g_string_append_printf (s, "%d", page_ranges[i].start);
+      else
+	g_string_append_printf (s, "%d-%d",
+				page_ranges[i].start,
+				page_ranges[i].end);
+      if (i < num_ranges - 1)
+	g_string_append (s, ",");
+    }
+
+  
+  gtk_print_settings_set (settings, GTK_PRINT_SETTINGS_PAGE_RANGES, 
+			  s->str);
+
+  g_string_free (s, TRUE);
+}
+
+G_CONST_RETURN gchar *
+gtk_print_settings_get_default_source (GtkPrintSettings *settings)
+{
+  return gtk_print_settings_get (settings, GTK_PRINT_SETTINGS_DEFAULT_SOURCE);
+}
+
+void
+gtk_print_settings_set_default_source (GtkPrintSettings *settings,
+				       const gchar      *default_source)
+{
+  gtk_print_settings_set (settings, GTK_PRINT_SETTINGS_DEFAULT_SOURCE, default_source);
+}
+     
+G_CONST_RETURN gchar *
+gtk_print_settings_get_media_type (GtkPrintSettings *settings)
+{
+  return gtk_print_settings_get (settings, GTK_PRINT_SETTINGS_MEDIA_TYPE);
+}
+
+/* The set of media types is defined in PWG 5101.1-2002 PWG */
+void
+gtk_print_settings_set_media_type (GtkPrintSettings *settings,
+				   const gchar      *media_type)
+{
+  gtk_print_settings_set (settings, GTK_PRINT_SETTINGS_MEDIA_TYPE, media_type);
+}
+
+
+G_CONST_RETURN gchar *
+gtk_print_settings_get_dither (GtkPrintSettings *settings)
+{
+  return gtk_print_settings_get (settings, GTK_PRINT_SETTINGS_DITHER);
+}
+
+void
+gtk_print_settings_set_dither (GtkPrintSettings *settings,
+			       const gchar      *dither)
+{
+  gtk_print_settings_set (settings, GTK_PRINT_SETTINGS_DITHER, dither);
+}
+     
+const gchar *
+gtk_print_settings_get_finishings (GtkPrintSettings *settings)
+{
+  return gtk_print_settings_get (settings, GTK_PRINT_SETTINGS_FINISHINGS);
+}
+
+void
+gtk_print_settings_set_finishings (GtkPrintSettings *settings,
+				   const gchar      *finishings)
+{
+  gtk_print_settings_set (settings, GTK_PRINT_SETTINGS_FINISHINGS, finishings);
+}
+     
+G_CONST_RETURN gchar *
+gtk_print_settings_get_output_bin (GtkPrintSettings *settings)
+{
+  return gtk_print_settings_get (settings, GTK_PRINT_SETTINGS_OUTPUT_BIN);
+}
+
+void
+gtk_print_settings_set_output_bin (GtkPrintSettings *settings,
+				   const gchar      *output_bin)
+{
+  gtk_print_settings_set (settings, GTK_PRINT_SETTINGS_OUTPUT_BIN, output_bin);
+}
+   
+
+#define __GTK_PRINT_SETTINGS_C__
+#include "gtkaliasdef.c"