Pileus Git - ~andy/gtk/blob - gtk/gtkprintsettings.c

   1 /* GTK - The GIMP Toolkit
   2  * gtkprintsettings.c: Print Settings
   3  * Copyright (C) 2006, Red Hat, Inc.
   4  *
   5  * This library is free software; you can redistribute it and/or
   6  * modify it under the terms of the GNU Lesser General Public
   7  * License as published by the Free Software Foundation; either
   8  * version 2 of the License, or (at your option) any later version.
   9  *
  10  * This library is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13  * Lesser General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU Lesser General Public
  16  * License along with this library; if not, write to the
  17  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  18  * Boston, MA 02111-1307, USA.
  19  */
  20
  21 #include "config.h"
  22
  23 #include <string.h>
  24 #include <stdlib.h>
  25
  26 #include <glib/gprintf.h>
  27
  28 #include "gtkprintsettings.h"
  29 #include "gtkprintutils.h"
  30 #include "gtktypebuiltins.h"
  31 #include "gtkwidget.h"
  32
  33
  34 /**
  35  * SECTION:gtkprintsettings
  36  * @Short_description: Stores print settings
  37  * @Title: GtkPrintSettings
  38  *
  39  * A GtkPrintSettings object represents the settings of a print dialog in
  40  * a system-independent way. The main use for this object is that once
  41  * you've printed you can get a settings object that represents the settings
  42  * the user chose, and the next time you print you can pass that object in so
  43  * that the user doesn't have to re-set all his settings.
  44  *
  45  * Its also possible to enumerate the settings so that you can easily save
  46  * the settings for the next time your app runs, or even store them in a
  47  * document. The predefined keys try to use shared values as much as possible
  48  * so that moving such a document between systems still works.
  49  *
  50  * <!-- TODO example of getting, storing and setting settings -->
  51  *
  52  * Printing support was added in GTK+ 2.10.
  53  */
  54
  55
  56 typedef struct _GtkPrintSettingsClass GtkPrintSettingsClass;
  57
  58 #define GTK_IS_PRINT_SETTINGS_CLASS(klass)  (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_PRINT_SETTINGS))
  59 #define GTK_PRINT_SETTINGS_CLASS(klass)     (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_PRINT_SETTINGS, GtkPrintSettingsClass))
  60 #define GTK_PRINT_SETTINGS_GET_CLASS(obj)   (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_PRINT_SETTINGS, GtkPrintSettingsClass))
  61
  62 struct _GtkPrintSettings
  63 {
  64   GObject parent_instance;
  65
  66   GHashTable *hash;
  67 };
  68
  69 struct _GtkPrintSettingsClass
  70 {
  71   GObjectClass parent_class;
  72 };
  73
  74 #define KEYFILE_GROUP_NAME "Print Settings"
  75
  76 G_DEFINE_TYPE (GtkPrintSettings, gtk_print_settings, G_TYPE_OBJECT)
  77
  78 static void
  79 gtk_print_settings_finalize (GObject *object)
  80 {
  81   GtkPrintSettings *settings = GTK_PRINT_SETTINGS (object);
  82
  83   g_hash_table_destroy (settings->hash);
  84
  85   G_OBJECT_CLASS (gtk_print_settings_parent_class)->finalize (object);
  86 }
  87
  88 static void
  89 gtk_print_settings_init (GtkPrintSettings *settings)
  90 {
  91   settings->hash = g_hash_table_new_full (g_str_hash, g_str_equal,
  92                                           g_free, g_free);
  93 }
  94
  95 static void
  96 gtk_print_settings_class_init (GtkPrintSettingsClass *class)
  97 {
  98   GObjectClass *gobject_class = (GObjectClass *)class;
  99
 100   gobject_class->finalize = gtk_print_settings_finalize;
 101 }
 102
 103 /**
 104  * gtk_print_settings_new:
 105  *
 106  * Creates a new #GtkPrintSettings object.
 107  *
 108  * Return value: a new #GtkPrintSettings object
 109  *
 110  * Since: 2.10
 111  */
 112 GtkPrintSettings *
 113 gtk_print_settings_new (void)
 114 {
 115   return g_object_new (GTK_TYPE_PRINT_SETTINGS, NULL);
 116 }
 117
 118 static void
 119 copy_hash_entry  (gpointer  key,
 120                   gpointer  value,
 121                   gpointer  user_data)
 122 {
 123   GtkPrintSettings *settings = user_data;
 124
 125   g_hash_table_insert (settings->hash,
 126                        g_strdup (key),
 127                        g_strdup (value));
 128 }
 129
 130
 131
 132 /**
 133  * gtk_print_settings_copy:
 134  * @other: a #GtkPrintSettings
 135  *
 136  * Copies a #GtkPrintSettings object.
 137  *
 138  * Return value: (transfer full): a newly allocated copy of @other
 139  *
 140  * Since: 2.10
 141  */
 142 GtkPrintSettings *
 143 gtk_print_settings_copy (GtkPrintSettings *other)
 144 {
 145   GtkPrintSettings *settings;
 146
 147   if (other == NULL)
 148     return NULL;
 149
 150   g_return_val_if_fail (GTK_IS_PRINT_SETTINGS (other), NULL);
 151
 152   settings = gtk_print_settings_new ();
 153
 154   g_hash_table_foreach (other->hash,
 155                         copy_hash_entry,
 156                         settings);
 157
 158   return settings;
 159 }
 160
 161 /**
 162  * gtk_print_settings_get:
 163  * @settings: a #GtkPrintSettings
 164  * @key: a key
 165  *
 166  * Looks up the string value associated with @key.
 167  *
 168  * Return value: the string value for @key
 169  *
 170  * Since: 2.10
 171  */
 172 G_CONST_RETURN gchar *
 173 gtk_print_settings_get (GtkPrintSettings *settings,
 174                         const gchar      *key)
 175 {
 176   return g_hash_table_lookup (settings->hash, key);
 177 }
 178
 179 /**
 180  * gtk_print_settings_set:
 181  * @settings: a #GtkPrintSettings
 182  * @key: a key
 183  * @value: (allow-none): a string value, or %NULL
 184  *
 185  * Associates @value with @key.
 186  *
 187  * Since: 2.10
 188  */
 189 void
 190 gtk_print_settings_set (GtkPrintSettings *settings,
 191                         const gchar      *key,
 192                         const gchar      *value)
 193 {
 194   if (value == NULL)
 195     gtk_print_settings_unset (settings, key);
 196   else
 197     g_hash_table_insert (settings->hash,
 198                          g_strdup (key),
 199                          g_strdup (value));
 200 }
 201
 202 /**
 203  * gtk_print_settings_unset:
 204  * @settings: a #GtkPrintSettings
 205  * @key: a key
 206  *
 207  * Removes any value associated with @key.
 208  * This has the same effect as setting the value to %NULL.
 209  *
 210  * Since: 2.10
 211  */
 212 void
 213 gtk_print_settings_unset (GtkPrintSettings *settings,
 214                           const gchar      *key)
 215 {
 216   g_hash_table_remove (settings->hash, key);
 217 }
 218
 219 /**
 220  * gtk_print_settings_has_key:
 221  * @settings: a #GtkPrintSettings
 222  * @key: a key
 223  *
 224  * Returns %TRUE, if a value is associated with @key.
 225  *
 226  * Return value: %TRUE, if @key has a value
 227  *
 228  * Since: 2.10
 229  */
 230 gboolean
 231 gtk_print_settings_has_key (GtkPrintSettings *settings,
 232                             const gchar      *key)
 233 {
 234   return gtk_print_settings_get (settings, key) != NULL;
 235 }
 236
 237
 238 /**
 239  * gtk_print_settings_get_bool:
 240  * @settings: a #GtkPrintSettings
 241  * @key: a key
 242  *
 243  * Returns the boolean represented by the value
 244  * that is associated with @key.
 245  *
 246  * The string "true" represents %TRUE, any other
 247  * string %FALSE.
 248  *
 249  * Return value: %TRUE, if @key maps to a true value.
 250  *
 251  * Since: 2.10
 252  **/
 253 gboolean
 254 gtk_print_settings_get_bool (GtkPrintSettings *settings,
 255                              const gchar      *key)
 256 {
 257   const gchar *val;
 258
 259   val = gtk_print_settings_get (settings, key);
 260   if (g_strcmp0 (val, "true") == 0)
 261     return TRUE;
 262
 263   return FALSE;
 264 }
 265
 266 /**
 267  * gtk_print_settings_get_bool_with_default:
 268  * @settings: a #GtkPrintSettings
 269  * @key: a key
 270  * @default_val: the default value
 271  *
 272  * Returns the boolean represented by the value
 273  * that is associated with @key, or @default_val
 274  * if the value does not represent a boolean.
 275  *
 276  * The string "true" represents %TRUE, the string
 277  * "false" represents %FALSE.
 278  *
 279  * Return value: the boolean value associated with @key
 280  *
 281  * Since: 2.10
 282  */
 283 static gboolean
 284 gtk_print_settings_get_bool_with_default (GtkPrintSettings *settings,
 285                                           const gchar      *key,
 286                                           gboolean          default_val)
 287 {
 288   const gchar *val;
 289
 290   val = gtk_print_settings_get (settings, key);
 291   if (g_strcmp0 (val, "true") == 0)
 292     return TRUE;
 293
 294   if (g_strcmp0 (val, "false") == 0)
 295     return FALSE;
 296
 297   return default_val;
 298 }
 299
 300 /**
 301  * gtk_print_settings_set_bool:
 302  * @settings: a #GtkPrintSettings
 303  * @key: a key
 304  * @value: a boolean
 305  *
 306  * Sets @key to a boolean value.
 307  *
 308  * Since: 2.10
 309  */
 310 void
 311 gtk_print_settings_set_bool (GtkPrintSettings *settings,
 312                              const gchar      *key,
 313                              gboolean          value)
 314 {
 315   if (value)
 316     gtk_print_settings_set (settings, key, "true");
 317   else
 318     gtk_print_settings_set (settings, key, "false");
 319 }
 320
 321 /**
 322  * gtk_print_settings_get_double_with_default:
 323  * @settings: a #GtkPrintSettings
 324  * @key: a key
 325  * @def: the default value
 326  *
 327  * Returns the floating point number represented by
 328  * the value that is associated with @key, or @default_val
 329  * if the value does not represent a floating point number.
 330  *
 331  * Floating point numbers are parsed with g_ascii_strtod().
 332  *
 333  * Return value: the floating point number associated with @key
 334  *
 335  * Since: 2.10
 336  */
 337 gdouble
 338 gtk_print_settings_get_double_with_default (GtkPrintSettings *settings,
 339                                             const gchar      *key,
 340                                             gdouble           def)
 341 {
 342   const gchar *val;
 343
 344   val = gtk_print_settings_get (settings, key);
 345   if (val == NULL)
 346     return def;
 347
 348   return g_ascii_strtod (val, NULL);
 349 }
 350
 351 /**
 352  * gtk_print_settings_get_double:
 353  * @settings: a #GtkPrintSettings
 354  * @key: a key
 355  *
 356  * Returns the double value associated with @key, or 0.
 357  *
 358  * Return value: the double value of @key
 359  *
 360  * Since: 2.10
 361  */
 362 gdouble
 363 gtk_print_settings_get_double (GtkPrintSettings *settings,
 364                                const gchar      *key)
 365 {
 366   return gtk_print_settings_get_double_with_default (settings, key, 0.0);
 367 }
 368
 369 /**
 370  * gtk_print_settings_set_double:
 371  * @settings: a #GtkPrintSettings
 372  * @key: a key
 373  * @value: a double value
 374  *
 375  * Sets @key to a double value.
 376  *
 377  * Since: 2.10
 378  */
 379 void
 380 gtk_print_settings_set_double (GtkPrintSettings *settings,
 381                                const gchar      *key,
 382                                gdouble           value)
 383 {
 384   gchar buf[G_ASCII_DTOSTR_BUF_SIZE];
 385
 386   g_ascii_dtostr (buf, G_ASCII_DTOSTR_BUF_SIZE, value);
 387   gtk_print_settings_set (settings, key, buf);
 388 }
 389
 390 /**
 391  * gtk_print_settings_get_length:
 392  * @settings: a #GtkPrintSettings
 393  * @key: a key
 394  * @unit: the unit of the return value
 395  *
 396  * Returns the value associated with @key, interpreted
 397  * as a length. The returned value is converted to @units.
 398  *
 399  * Return value: the length value of @key, converted to @unit
 400  *
 401  * Since: 2.10
 402  */
 403 gdouble
 404 gtk_print_settings_get_length (GtkPrintSettings *settings,
 405                                const gchar      *key,
 406                                GtkUnit           unit)
 407 {
 408   gdouble length = gtk_print_settings_get_double (settings, key);
 409   return _gtk_print_convert_from_mm (length, unit);
 410 }
 411
 412 /**
 413  * gtk_print_settings_set_length:
 414  * @settings: a #GtkPrintSettings
 415  * @key: a key
 416  * @value: a length
 417  * @unit: the unit of @length
 418  *
 419  * Associates a length in units of @unit with @key.
 420  *
 421  * Since: 2.10
 422  */
 423 void
 424 gtk_print_settings_set_length (GtkPrintSettings *settings,
 425                                const gchar      *key,
 426                                gdouble           value,
 427                                GtkUnit           unit)
 428 {
 429   gtk_print_settings_set_double (settings, key,
 430                                  _gtk_print_convert_to_mm (value, unit));
 431 }
 432
 433 /**
 434  * gtk_print_settings_get_int_with_default:
 435  * @settings: a #GtkPrintSettings
 436  * @key: a key
 437  * @def: the default value
 438  *
 439  * Returns the value of @key, interpreted as
 440  * an integer, or the default value.
 441  *
 442  * Return value: the integer value of @key
 443  *
 444  * Since: 2.10
 445  */
 446 gint
 447 gtk_print_settings_get_int_with_default (GtkPrintSettings *settings,
 448                                          const gchar      *key,
 449                                          gint              def)
 450 {
 451   const gchar *val;
 452
 453   val = gtk_print_settings_get (settings, key);
 454   if (val == NULL)
 455     return def;
 456
 457   return atoi (val);
 458 }
 459
 460 /**
 461  * gtk_print_settings_get_int:
 462  * @settings: a #GtkPrintSettings
 463  * @key: a key
 464  *
 465  * Returns the integer value of @key, or 0.
 466  *
 467  * Return value: the integer value of @key
 468  *
 469  * Since: 2.10
 470  */
 471 gint
 472 gtk_print_settings_get_int (GtkPrintSettings *settings,
 473                             const gchar      *key)
 474 {
 475   return gtk_print_settings_get_int_with_default (settings, key, 0);
 476 }
 477
 478 /**
 479  * gtk_print_settings_set_int:
 480  * @settings: a #GtkPrintSettings
 481  * @key: a key
 482  * @value: an integer
 483  *
 484  * Sets @key to an integer value.
 485  *
 486  * Since: 2.10
 487  */
 488 void
 489 gtk_print_settings_set_int (GtkPrintSettings *settings,
 490                             const gchar      *key,
 491                             gint              value)
 492 {
 493   gchar buf[128];
 494   g_sprintf (buf, "%d", value);
 495   gtk_print_settings_set (settings, key, buf);
 496 }
 497
 498 /**
 499  * gtk_print_settings_foreach:
 500  * @settings: a #GtkPrintSettings
 501  * @func: (scope call): the function to call
 502  * @user_data: user data for @func
 503  *
 504  * Calls @func for each key-value pair of @settings.
 505  *
 506  * Since: 2.10
 507  */
 508 void
 509 gtk_print_settings_foreach (GtkPrintSettings    *settings,
 510                             GtkPrintSettingsFunc func,
 511                             gpointer             user_data)
 512 {
 513   g_hash_table_foreach (settings->hash, (GHFunc)func, user_data);
 514 }
 515
 516 /**
 517  * gtk_print_settings_get_printer:
 518  * @settings: a #GtkPrintSettings
 519  *
 520  * Convenience function to obtain the value of
 521  * %GTK_PRINT_SETTINGS_PRINTER.
 522  *
 523  * Return value: the printer name
 524  *
 525  * Since: 2.10
 526  */
 527 G_CONST_RETURN gchar *
 528 gtk_print_settings_get_printer (GtkPrintSettings *settings)
 529 {
 530   return gtk_print_settings_get (settings, GTK_PRINT_SETTINGS_PRINTER);
 531 }
 532
 533
 534 /**
 535  * gtk_print_settings_set_printer:
 536  * @settings: a #GtkPrintSettings
 537  * @printer: the printer name
 538  *
 539  * Convenience function to set %GTK_PRINT_SETTINGS_PRINTER
 540  * to @printer.
 541  *
 542  * Since: 2.10
 543  */
 544 void
 545 gtk_print_settings_set_printer (GtkPrintSettings *settings,
 546                                 const gchar      *printer)
 547 {
 548   gtk_print_settings_set (settings, GTK_PRINT_SETTINGS_PRINTER, printer);
 549 }
 550
 551 /**
 552  * gtk_print_settings_get_orientation:
 553  * @settings: a #GtkPrintSettings
 554  *
 555  * Get the value of %GTK_PRINT_SETTINGS_ORIENTATION,
 556  * converted to a #GtkPageOrientation.
 557  *
 558  * Return value: the orientation
 559  *
 560  * Since: 2.10
 561  */
 562 GtkPageOrientation
 563 gtk_print_settings_get_orientation (GtkPrintSettings *settings)
 564 {
 565   const gchar *val;
 566
 567   val = gtk_print_settings_get (settings, GTK_PRINT_SETTINGS_ORIENTATION);
 568
 569   if (val == NULL || strcmp (val, "portrait") == 0)
 570     return GTK_PAGE_ORIENTATION_PORTRAIT;
 571
 572   if (strcmp (val, "landscape") == 0)
 573     return GTK_PAGE_ORIENTATION_LANDSCAPE;
 574
 575   if (strcmp (val, "reverse_portrait") == 0)
 576     return GTK_PAGE_ORIENTATION_REVERSE_PORTRAIT;
 577
 578   if (strcmp (val, "reverse_landscape") == 0)
 579     return GTK_PAGE_ORIENTATION_REVERSE_LANDSCAPE;
 580
 581   return GTK_PAGE_ORIENTATION_PORTRAIT;
 582 }
 583
 584 /**
 585  * gtk_print_settings_set_orientation:
 586  * @settings: a #GtkPrintSettings
 587  * @orientation: a page orientation
 588  *
 589  * Sets the value of %GTK_PRINT_SETTINGS_ORIENTATION.
 590  *
 591  * Since: 2.10
 592  */
 593 void
 594 gtk_print_settings_set_orientation (GtkPrintSettings   *settings,
 595                                     GtkPageOrientation  orientation)
 596 {
 597   const gchar *val;
 598
 599   switch (orientation)
 600     {
 601     case GTK_PAGE_ORIENTATION_LANDSCAPE:
 602       val = "landscape";
 603       break;
 604     default:
 605     case GTK_PAGE_ORIENTATION_PORTRAIT:
 606       val = "portrait";
 607       break;
 608     case GTK_PAGE_ORIENTATION_REVERSE_LANDSCAPE:
 609       val = "reverse_landscape";
 610       break;
 611     case GTK_PAGE_ORIENTATION_REVERSE_PORTRAIT:
 612       val = "reverse_portrait";
 613       break;
 614     }
 615   gtk_print_settings_set (settings, GTK_PRINT_SETTINGS_ORIENTATION, val);
 616 }
 617
 618 /**
 619  * gtk_print_settings_get_paper_size:
 620  * @settings: a #GtkPrintSettings
 621  *
 622  * Gets the value of %GTK_PRINT_SETTINGS_PAPER_FORMAT,
 623  * converted to a #GtkPaperSize.
 624  *
 625  * Return value: the paper size
 626  *
 627  * Since: 2.10
 628  */
 629 GtkPaperSize *
 630 gtk_print_settings_get_paper_size (GtkPrintSettings *settings)
 631 {
 632   const gchar *val;
 633   const gchar *name;
 634   gdouble w, h;
 635
 636   val = gtk_print_settings_get (settings, GTK_PRINT_SETTINGS_PAPER_FORMAT);
 637   if (val == NULL)
 638     return NULL;
 639
 640   if (g_str_has_prefix (val, "custom-"))
 641     {
 642       name = val + strlen ("custom-");
 643       w = gtk_print_settings_get_paper_width (settings, GTK_UNIT_MM);
 644       h = gtk_print_settings_get_paper_height (settings, GTK_UNIT_MM);
 645       return gtk_paper_size_new_custom (name, name, w, h, GTK_UNIT_MM);
 646     }
 647
 648   return gtk_paper_size_new (val);
 649 }
 650
 651 /**
 652  * gtk_print_settings_set_paper_size:
 653  * @settings: a #GtkPrintSettings
 654  * @paper_size: a paper size
 655  *
 656  * Sets the value of %GTK_PRINT_SETTINGS_PAPER_FORMAT,
 657  * %GTK_PRINT_SETTINGS_PAPER_WIDTH and
 658  * %GTK_PRINT_SETTINGS_PAPER_HEIGHT.
 659  *
 660  * Since: 2.10
 661  */
 662 void
 663 gtk_print_settings_set_paper_size (GtkPrintSettings *settings,
 664                                    GtkPaperSize     *paper_size)
 665 {
 666   gchar *custom_name;
 667
 668   if (paper_size == NULL)
 669     {
 670       gtk_print_settings_set (settings, GTK_PRINT_SETTINGS_PAPER_FORMAT, NULL);
 671       gtk_print_settings_set (settings, GTK_PRINT_SETTINGS_PAPER_WIDTH, NULL);
 672       gtk_print_settings_set (settings, GTK_PRINT_SETTINGS_PAPER_HEIGHT, NULL);
 673     }
 674   else if (gtk_paper_size_is_custom (paper_size))
 675     {
 676       custom_name = g_strdup_printf ("custom-%s",
 677                                      gtk_paper_size_get_name (paper_size));
 678       gtk_print_settings_set (settings, GTK_PRINT_SETTINGS_PAPER_FORMAT, custom_name);
 679       g_free (custom_name);
 680       gtk_print_settings_set_paper_width (settings,
 681                                           gtk_paper_size_get_width (paper_size,
 682                                                                     GTK_UNIT_MM),
 683                                           GTK_UNIT_MM);
 684       gtk_print_settings_set_paper_height (settings,
 685                                            gtk_paper_size_get_height (paper_size,
 686                                                                       GTK_UNIT_MM),
 687                                            GTK_UNIT_MM);
 688     }
 689   else
 690     gtk_print_settings_set (settings, GTK_PRINT_SETTINGS_PAPER_FORMAT,
 691                             gtk_paper_size_get_name (paper_size));
 692 }
 693
 694 /**
 695  * gtk_print_settings_get_paper_width:
 696  * @settings: a #GtkPrintSettings
 697  * @unit: the unit for the return value
 698  *
 699  * Gets the value of %GTK_PRINT_SETTINGS_PAPER_WIDTH,
 700  * converted to @unit.
 701  *
 702  * Return value: the paper width, in units of @unit
 703  *
 704  * Since: 2.10
 705  */
 706 gdouble
 707 gtk_print_settings_get_paper_width (GtkPrintSettings *settings,
 708                                     GtkUnit           unit)
 709 {
 710   return gtk_print_settings_get_length (settings, GTK_PRINT_SETTINGS_PAPER_WIDTH, unit);
 711 }
 712
 713 /**
 714  * gtk_print_settings_set_paper_width:
 715  * @settings: a #GtkPrintSettings
 716  * @width: the paper width
 717  * @unit: the units of @width
 718  *
 719  * Sets the value of %GTK_PRINT_SETTINGS_PAPER_WIDTH.
 720  *
 721  * Since: 2.10
 722  */
 723 void
 724 gtk_print_settings_set_paper_width (GtkPrintSettings *settings,
 725                                     gdouble           width,
 726                                     GtkUnit           unit)
 727 {
 728   gtk_print_settings_set_length (settings, GTK_PRINT_SETTINGS_PAPER_WIDTH, width, unit);
 729 }
 730
 731 /**
 732  * gtk_print_settings_get_paper_height:
 733  * @settings: a #GtkPrintSettings
 734  * @unit: the unit for the return value
 735  *
 736  * Gets the value of %GTK_PRINT_SETTINGS_PAPER_HEIGHT,
 737  * converted to @unit.
 738  *
 739  * Return value: the paper height, in units of @unit
 740  *
 741  * Since: 2.10
 742  */
 743 gdouble
 744 gtk_print_settings_get_paper_height (GtkPrintSettings *settings,
 745                                      GtkUnit           unit)
 746 {
 747   return gtk_print_settings_get_length (settings,
 748                                         GTK_PRINT_SETTINGS_PAPER_HEIGHT,
 749                                         unit);
 750 }
 751
 752 /**
 753  * gtk_print_settings_set_paper_height:
 754  * @settings: a #GtkPrintSettings
 755  * @height: the paper height
 756  * @unit: the units of @height
 757  *
 758  * Sets the value of %GTK_PRINT_SETTINGS_PAPER_HEIGHT.
 759  *
 760  * Since: 2.10
 761  */
 762 void
 763 gtk_print_settings_set_paper_height (GtkPrintSettings *settings,
 764                                      gdouble           height,
 765                                      GtkUnit           unit)
 766 {
 767   gtk_print_settings_set_length (settings,
 768                                  GTK_PRINT_SETTINGS_PAPER_HEIGHT,
 769                                  height, unit);
 770 }
 771
 772 /**
 773  * gtk_print_settings_get_use_color:
 774  * @settings: a #GtkPrintSettings
 775  *
 776  * Gets the value of %GTK_PRINT_SETTINGS_USE_COLOR.
 777  *
 778  * Return value: whether to use color
 779  *
 780  * Since: 2.10
 781  */
 782 gboolean
 783 gtk_print_settings_get_use_color (GtkPrintSettings *settings)
 784 {
 785   return gtk_print_settings_get_bool_with_default (settings,
 786                                                    GTK_PRINT_SETTINGS_USE_COLOR,
 787                                                    TRUE);
 788 }
 789
 790 /**
 791  * gtk_print_settings_set_use_color:
 792  * @settings: a #GtkPrintSettings
 793  * @use_color: whether to use color
 794  *
 795  * Sets the value of %GTK_PRINT_SETTINGS_USE_COLOR.
 796  *
 797  * Since: 2.10
 798  */
 799 void
 800 gtk_print_settings_set_use_color (GtkPrintSettings *settings,
 801                                   gboolean          use_color)
 802 {
 803   gtk_print_settings_set_bool (settings,
 804                                GTK_PRINT_SETTINGS_USE_COLOR,
 805                                use_color);
 806 }
 807
 808 /**
 809  * gtk_print_settings_get_collate:
 810  * @settings: a #GtkPrintSettings
 811  *
 812  * Gets the value of %GTK_PRINT_SETTINGS_COLLATE.
 813  *
 814  * Return value: whether to collate the printed pages
 815  *
 816  * Since: 2.10
 817  */
 818 gboolean
 819 gtk_print_settings_get_collate (GtkPrintSettings *settings)
 820 {
 821   return gtk_print_settings_get_bool (settings,
 822                                       GTK_PRINT_SETTINGS_COLLATE);
 823 }
 824
 825 /**
 826  * gtk_print_settings_set_collate:
 827  * @settings: a #GtkPrintSettings
 828  * @collate: whether to collate the output
 829  *
 830  * Sets the value of %GTK_PRINT_SETTINGS_COLLATE.
 831  *
 832  * Since: 2.10
 833  */
 834 void
 835 gtk_print_settings_set_collate (GtkPrintSettings *settings,
 836                                 gboolean          collate)
 837 {
 838   gtk_print_settings_set_bool (settings,
 839                                GTK_PRINT_SETTINGS_COLLATE,
 840                                collate);
 841 }
 842
 843 /**
 844  * gtk_print_settings_get_reverse:
 845  * @settings: a #GtkPrintSettings
 846  *
 847  * Gets the value of %GTK_PRINT_SETTINGS_REVERSE.
 848  *
 849  * Return value: whether to reverse the order of the printed pages
 850  *
 851  * Since: 2.10
 852  */
 853 gboolean
 854 gtk_print_settings_get_reverse (GtkPrintSettings *settings)
 855 {
 856   return gtk_print_settings_get_bool (settings,
 857                                       GTK_PRINT_SETTINGS_REVERSE);
 858 }
 859
 860 /**
 861  * gtk_print_settings_set_reverse:
 862  * @settings: a #GtkPrintSettings
 863  * @reverse: whether to reverse the output
 864  *
 865  * Sets the value of %GTK_PRINT_SETTINGS_REVERSE.
 866  *
 867  * Since: 2.10
 868  */
 869 void
 870 gtk_print_settings_set_reverse (GtkPrintSettings *settings,
 871                                   gboolean        reverse)
 872 {
 873   gtk_print_settings_set_bool (settings,
 874                                GTK_PRINT_SETTINGS_REVERSE,
 875                                reverse);
 876 }
 877
 878 /**
 879  * gtk_print_settings_get_duplex:
 880  * @settings: a #GtkPrintSettings
 881  *
 882  * Gets the value of %GTK_PRINT_SETTINGS_DUPLEX.
 883  *
 884  * Return value: whether to print the output in duplex.
 885  *
 886  * Since: 2.10
 887  */
 888 GtkPrintDuplex
 889 gtk_print_settings_get_duplex (GtkPrintSettings *settings)
 890 {
 891   const gchar *val;
 892
 893   val = gtk_print_settings_get (settings, GTK_PRINT_SETTINGS_DUPLEX);
 894
 895   if (val == NULL || (strcmp (val, "simplex") == 0))
 896     return GTK_PRINT_DUPLEX_SIMPLEX;
 897
 898   if (strcmp (val, "horizontal") == 0)
 899     return GTK_PRINT_DUPLEX_HORIZONTAL;
 900
 901   if (strcmp (val, "vertical") == 0)
 902     return GTK_PRINT_DUPLEX_VERTICAL;
 903
 904   return GTK_PRINT_DUPLEX_SIMPLEX;
 905 }
 906
 907 /**
 908  * gtk_print_settings_set_duplex:
 909  * @settings: a #GtkPrintSettings
 910  * @duplex: a #GtkPrintDuplex value
 911  *
 912  * Sets the value of %GTK_PRINT_SETTINGS_DUPLEX.
 913  *
 914  * Since: 2.10
 915  */
 916 void
 917 gtk_print_settings_set_duplex (GtkPrintSettings *settings,
 918                                GtkPrintDuplex    duplex)
 919 {
 920   const gchar *str;
 921
 922   switch (duplex)
 923     {
 924     default:
 925     case GTK_PRINT_DUPLEX_SIMPLEX:
 926       str = "simplex";
 927       break;
 928     case GTK_PRINT_DUPLEX_HORIZONTAL:
 929       str = "horizontal";
 930       break;
 931     case GTK_PRINT_DUPLEX_VERTICAL:
 932       str = "vertical";
 933       break;
 934     }
 935
 936   gtk_print_settings_set (settings, GTK_PRINT_SETTINGS_DUPLEX, str);
 937 }
 938
 939 /**
 940  * gtk_print_settings_get_quality:
 941  * @settings: a #GtkPrintSettings
 942  *
 943  * Gets the value of %GTK_PRINT_SETTINGS_QUALITY.
 944  *
 945  * Return value: the print quality
 946  *
 947  * Since: 2.10
 948  */
 949 GtkPrintQuality
 950 gtk_print_settings_get_quality (GtkPrintSettings *settings)
 951 {
 952   const gchar *val;
 953
 954   val = gtk_print_settings_get (settings, GTK_PRINT_SETTINGS_QUALITY);
 955
 956   if (val == NULL || (strcmp (val, "normal") == 0))
 957     return GTK_PRINT_QUALITY_NORMAL;
 958
 959   if (strcmp (val, "high") == 0)
 960     return GTK_PRINT_QUALITY_HIGH;
 961
 962   if (strcmp (val, "low") == 0)
 963     return GTK_PRINT_QUALITY_LOW;
 964
 965   if (strcmp (val, "draft") == 0)
 966     return GTK_PRINT_QUALITY_DRAFT;
 967
 968   return GTK_PRINT_QUALITY_NORMAL;
 969 }
 970
 971 /**
 972  * gtk_print_settings_set_quality:
 973  * @settings: a #GtkPrintSettings
 974  * @quality: a #GtkPrintQuality value
 975  *
 976  * Sets the value of %GTK_PRINT_SETTINGS_QUALITY.
 977  *
 978  * Since: 2.10
 979  */
 980 void
 981 gtk_print_settings_set_quality (GtkPrintSettings *settings,
 982                                 GtkPrintQuality   quality)
 983 {
 984   const gchar *str;
 985
 986   switch (quality)
 987     {
 988     default:
 989     case GTK_PRINT_QUALITY_NORMAL:
 990       str = "normal";
 991       break;
 992     case GTK_PRINT_QUALITY_HIGH:
 993       str = "high";
 994       break;
 995     case GTK_PRINT_QUALITY_LOW:
 996       str = "low";
 997       break;
 998     case GTK_PRINT_QUALITY_DRAFT:
 999       str = "draft";
1000       break;
1001     }
1002
1003   gtk_print_settings_set (settings, GTK_PRINT_SETTINGS_QUALITY, str);
1004 }
1005
1006 /**
1007  * gtk_print_settings_get_page_set:
1008  * @settings: a #GtkPrintSettings
1009  *
1010  * Gets the value of %GTK_PRINT_SETTINGS_PAGE_SET.
1011  *
1012  * Return value: the set of pages to print
1013  *
1014  * Since: 2.10
1015  */
1016 GtkPageSet
1017 gtk_print_settings_get_page_set (GtkPrintSettings *settings)
1018 {
1019   const gchar *val;
1020
1021   val = gtk_print_settings_get (settings, GTK_PRINT_SETTINGS_PAGE_SET);
1022
1023   if (val == NULL || (strcmp (val, "all") == 0))
1024     return GTK_PAGE_SET_ALL;
1025
1026   if (strcmp (val, "even") == 0)
1027     return GTK_PAGE_SET_EVEN;
1028
1029   if (strcmp (val, "odd") == 0)
1030     return GTK_PAGE_SET_ODD;
1031
1032   return GTK_PAGE_SET_ALL;
1033 }
1034
1035 /**
1036  * gtk_print_settings_set_page_set:
1037  * @settings: a #GtkPrintSettings
1038  * @page_set: a #GtkPageSet value
1039  *
1040  * Sets the value of %GTK_PRINT_SETTINGS_PAGE_SET.
1041  *
1042  * Since: 2.10
1043  */
1044 void
1045 gtk_print_settings_set_page_set (GtkPrintSettings *settings,
1046                                  GtkPageSet        page_set)
1047 {
1048   const gchar *str;
1049
1050   switch (page_set)
1051     {
1052     default:
1053     case GTK_PAGE_SET_ALL:
1054       str = "all";
1055       break;
1056     case GTK_PAGE_SET_EVEN:
1057       str = "even";
1058       break;
1059     case GTK_PAGE_SET_ODD:
1060       str = "odd";
1061       break;
1062     }
1063
1064   gtk_print_settings_set (settings, GTK_PRINT_SETTINGS_PAGE_SET, str);
1065 }
1066
1067 /**
1068  * gtk_print_settings_get_number_up_layout:
1069  * @settings: a #GtkPrintSettings
1070  *
1071  * Gets the value of %GTK_PRINT_SETTINGS_NUMBER_UP_LAYOUT.
1072  *
1073  * Return value: layout of page in number-up mode
1074  *
1075  * Since: 2.14
1076  */
1077 GtkNumberUpLayout
1078 gtk_print_settings_get_number_up_layout (GtkPrintSettings *settings)
1079 {
1080   GtkNumberUpLayout layout;
1081   GtkTextDirection  text_direction;
1082   GEnumClass       *enum_class;
1083   GEnumValue       *enum_value;
1084   const gchar      *val;
1085
1086   g_return_val_if_fail (GTK_IS_PRINT_SETTINGS (settings), GTK_NUMBER_UP_LAYOUT_LEFT_TO_RIGHT_TOP_TO_BOTTOM);
1087
1088   val = gtk_print_settings_get (settings, GTK_PRINT_SETTINGS_NUMBER_UP_LAYOUT);
1089   text_direction = gtk_widget_get_default_direction ();
1090
1091   if (text_direction == GTK_TEXT_DIR_LTR)
1092     layout = GTK_NUMBER_UP_LAYOUT_LEFT_TO_RIGHT_TOP_TO_BOTTOM;
1093   else
1094     layout = GTK_NUMBER_UP_LAYOUT_RIGHT_TO_LEFT_TOP_TO_BOTTOM;
1095
1096   if (val == NULL)
1097     return layout;
1098
1099   enum_class = g_type_class_ref (GTK_TYPE_NUMBER_UP_LAYOUT);
1100   enum_value = g_enum_get_value_by_nick (enum_class, val);
1101   if (enum_value)
1102     layout = enum_value->value;
1103   g_type_class_unref (enum_class);
1104
1105   return layout;
1106 }
1107
1108 /**
1109  * gtk_print_settings_set_number_up_layout:
1110  * @settings: a #GtkPrintSettings
1111  * @number_up_layout: a #GtkNumberUpLayout value
1112  *
1113  * Sets the value of %GTK_PRINT_SETTINGS_NUMBER_UP_LAYOUT.
1114  *
1115  * Since: 2.14
1116  */
1117 void
1118 gtk_print_settings_set_number_up_layout (GtkPrintSettings  *settings,
1119                                          GtkNumberUpLayout  number_up_layout)
1120 {
1121   GEnumClass *enum_class;
1122   GEnumValue *enum_value;
1123
1124   g_return_if_fail (GTK_IS_PRINT_SETTINGS (settings));
1125
1126   enum_class = g_type_class_ref (GTK_TYPE_NUMBER_UP_LAYOUT);
1127   enum_value = g_enum_get_value (enum_class, number_up_layout);
1128   g_return_if_fail (enum_value != NULL);
1129
1130   gtk_print_settings_set (settings, GTK_PRINT_SETTINGS_NUMBER_UP_LAYOUT, enum_value->value_nick);
1131   g_type_class_unref (enum_class);
1132 }
1133
1134 /**
1135  * gtk_print_settings_get_n_copies:
1136  * @settings: a #GtkPrintSettings
1137  *
1138  * Gets the value of %GTK_PRINT_SETTINGS_N_COPIES.
1139  *
1140  * Return value: the number of copies to print
1141  *
1142  * Since: 2.10
1143  */
1144 gint
1145 gtk_print_settings_get_n_copies (GtkPrintSettings *settings)
1146 {
1147   return gtk_print_settings_get_int_with_default (settings, GTK_PRINT_SETTINGS_N_COPIES, 1);
1148 }
1149
1150 /**
1151  * gtk_print_settings_set_n_copies:
1152  * @settings: a #GtkPrintSettings
1153  * @num_copies: the number of copies
1154  *
1155  * Sets the value of %GTK_PRINT_SETTINGS_N_COPIES.
1156  *
1157  * Since: 2.10
1158  */
1159 void
1160 gtk_print_settings_set_n_copies (GtkPrintSettings *settings,
1161                                  gint              num_copies)
1162 {
1163   gtk_print_settings_set_int (settings, GTK_PRINT_SETTINGS_N_COPIES,
1164                               num_copies);
1165 }
1166
1167 /**
1168  * gtk_print_settings_get_number_up:
1169  * @settings: a #GtkPrintSettings
1170  *
1171  * Gets the value of %GTK_PRINT_SETTINGS_NUMBER_UP.
1172  *
1173  * Return value: the number of pages per sheet
1174  *
1175  * Since: 2.10
1176  */
1177 gint
1178 gtk_print_settings_get_number_up (GtkPrintSettings *settings)
1179 {
1180   return gtk_print_settings_get_int_with_default (settings, GTK_PRINT_SETTINGS_NUMBER_UP, 1);
1181 }
1182
1183 /**
1184  * gtk_print_settings_set_number_up:
1185  * @settings: a #GtkPrintSettings
1186  * @number_up: the number of pages per sheet
1187  *
1188  * Sets the value of %GTK_PRINT_SETTINGS_NUMBER_UP.
1189  *
1190  * Since: 2.10
1191  */
1192 void
1193 gtk_print_settings_set_number_up (GtkPrintSettings *settings,
1194                                   gint              number_up)
1195 {
1196   gtk_print_settings_set_int (settings, GTK_PRINT_SETTINGS_NUMBER_UP,
1197                                 number_up);
1198 }
1199
1200 /**
1201  * gtk_print_settings_get_resolution:
1202  * @settings: a #GtkPrintSettings
1203  *
1204  * Gets the value of %GTK_PRINT_SETTINGS_RESOLUTION.
1205  *
1206  * Return value: the resolution in dpi
1207  *
1208  * Since: 2.10
1209  */
1210 gint
1211 gtk_print_settings_get_resolution (GtkPrintSettings *settings)
1212 {
1213   return gtk_print_settings_get_int_with_default (settings, GTK_PRINT_SETTINGS_RESOLUTION, 300);
1214 }
1215
1216 /**
1217  * gtk_print_settings_set_resolution:
1218  * @settings: a #GtkPrintSettings
1219  * @resolution: the resolution in dpi
1220  *
1221  * Sets the values of %GTK_PRINT_SETTINGS_RESOLUTION,
1222  * %GTK_PRINT_SETTINGS_RESOLUTION_X and
1223  * %GTK_PRINT_SETTINGS_RESOLUTION_Y.
1224  *
1225  * Since: 2.10
1226  */
1227 void
1228 gtk_print_settings_set_resolution (GtkPrintSettings *settings,
1229                                    gint              resolution)
1230 {
1231   gtk_print_settings_set_int (settings, GTK_PRINT_SETTINGS_RESOLUTION,
1232                               resolution);
1233   gtk_print_settings_set_int (settings, GTK_PRINT_SETTINGS_RESOLUTION_X,
1234                               resolution);
1235   gtk_print_settings_set_int (settings, GTK_PRINT_SETTINGS_RESOLUTION_Y,
1236                               resolution);
1237 }
1238
1239 /**
1240  * gtk_print_settings_get_resolution_x:
1241  * @settings: a #GtkPrintSettings
1242  *
1243  * Gets the value of %GTK_PRINT_SETTINGS_RESOLUTION_X.
1244  *
1245  * Return value: the horizontal resolution in dpi
1246  *
1247  * Since: 2.16
1248  */
1249 gint
1250 gtk_print_settings_get_resolution_x (GtkPrintSettings *settings)
1251 {
1252   return gtk_print_settings_get_int_with_default (settings, GTK_PRINT_SETTINGS_RESOLUTION_X, 300);
1253 }
1254
1255 /**
1256  * gtk_print_settings_get_resolution_y:
1257  * @settings: a #GtkPrintSettings
1258  *
1259  * Gets the value of %GTK_PRINT_SETTINGS_RESOLUTION_Y.
1260  *
1261  * Return value: the vertical resolution in dpi
1262  *
1263  * Since: 2.16
1264  */
1265 gint
1266 gtk_print_settings_get_resolution_y (GtkPrintSettings *settings)
1267 {
1268   return gtk_print_settings_get_int_with_default (settings, GTK_PRINT_SETTINGS_RESOLUTION_Y, 300);
1269 }
1270
1271 /**
1272  * gtk_print_settings_set_resolution_xy:
1273  * @settings: a #GtkPrintSettings
1274  * @resolution_x: the horizontal resolution in dpi
1275  * @resolution_y: the vertical resolution in dpi
1276  *
1277  * Sets the values of %GTK_PRINT_SETTINGS_RESOLUTION,
1278  * %GTK_PRINT_SETTINGS_RESOLUTION_X and
1279  * %GTK_PRINT_SETTINGS_RESOLUTION_Y.
1280  *
1281  * Since: 2.16
1282  */
1283 void
1284 gtk_print_settings_set_resolution_xy (GtkPrintSettings *settings,
1285                                       gint              resolution_x,
1286                                       gint              resolution_y)
1287 {
1288   gtk_print_settings_set_int (settings, GTK_PRINT_SETTINGS_RESOLUTION_X,
1289                               resolution_x);
1290   gtk_print_settings_set_int (settings, GTK_PRINT_SETTINGS_RESOLUTION_Y,
1291                               resolution_y);
1292   gtk_print_settings_set_int (settings, GTK_PRINT_SETTINGS_RESOLUTION,
1293                               resolution_x);
1294 }
1295
1296 /**
1297  * gtk_print_settings_get_printer_lpi:
1298  * @settings: a #GtkPrintSettings
1299  *
1300  * Gets the value of %GTK_PRINT_SETTINGS_PRINTER_LPI.
1301  *
1302  * Return value: the resolution in lpi (lines per inch)
1303  *
1304  * Since: 2.16
1305  */
1306 gdouble
1307 gtk_print_settings_get_printer_lpi (GtkPrintSettings *settings)
1308 {
1309   return gtk_print_settings_get_double_with_default (settings, GTK_PRINT_SETTINGS_PRINTER_LPI, 150.0);
1310 }
1311
1312 /**
1313  * gtk_print_settings_set_printer_lpi:
1314  * @settings: a #GtkPrintSettings
1315  * @lpi: the resolution in lpi (lines per inch)
1316  *
1317  * Sets the value of %GTK_PRINT_SETTINGS_PRINTER_LPI.
1318  *
1319  * Since: 2.16
1320  */
1321 void
1322 gtk_print_settings_set_printer_lpi (GtkPrintSettings *settings,
1323                                     gdouble           lpi)
1324 {
1325   gtk_print_settings_set_double (settings, GTK_PRINT_SETTINGS_PRINTER_LPI,
1326                                  lpi);
1327 }
1328
1329 /**
1330  * gtk_print_settings_get_scale:
1331  * @settings: a #GtkPrintSettings
1332  *
1333  * Gets the value of %GTK_PRINT_SETTINGS_SCALE.
1334  *
1335  * Return value: the scale in percent
1336  *
1337  * Since: 2.10
1338  */
1339 gdouble
1340 gtk_print_settings_get_scale (GtkPrintSettings *settings)
1341 {
1342   return gtk_print_settings_get_double_with_default (settings,
1343                                                      GTK_PRINT_SETTINGS_SCALE,
1344                                                      100.0);
1345 }
1346
1347 /**
1348  * gtk_print_settings_set_scale:
1349  * @settings: a #GtkPrintSettings
1350  * @scale: the scale in percent
1351  *
1352  * Sets the value of %GTK_PRINT_SETTINGS_SCALE.
1353  *
1354  * Since: 2.10
1355  */
1356 void
1357 gtk_print_settings_set_scale (GtkPrintSettings *settings,
1358                               gdouble           scale)
1359 {
1360   gtk_print_settings_set_double (settings, GTK_PRINT_SETTINGS_SCALE,
1361                                  scale);
1362 }
1363
1364 /**
1365  * gtk_print_settings_get_print_pages:
1366  * @settings: a #GtkPrintSettings
1367  *
1368  * Gets the value of %GTK_PRINT_SETTINGS_PRINT_PAGES.
1369  *
1370  * Return value: which pages to print
1371  *
1372  * Since: 2.10
1373  */
1374 GtkPrintPages
1375 gtk_print_settings_get_print_pages (GtkPrintSettings *settings)
1376 {
1377   const gchar *val;
1378
1379   val = gtk_print_settings_get (settings, GTK_PRINT_SETTINGS_PRINT_PAGES);
1380
1381   if (val == NULL || (strcmp (val, "all") == 0))
1382     return GTK_PRINT_PAGES_ALL;
1383
1384   if (strcmp (val, "selection") == 0)
1385     return GTK_PRINT_PAGES_SELECTION;
1386
1387   if (strcmp (val, "current") == 0)
1388     return GTK_PRINT_PAGES_CURRENT;
1389
1390   if (strcmp (val, "ranges") == 0)
1391     return GTK_PRINT_PAGES_RANGES;
1392
1393   return GTK_PRINT_PAGES_ALL;
1394 }
1395
1396 /**
1397  * gtk_print_settings_set_print_pages:
1398  * @settings: a #GtkPrintSettings
1399  * @pages: a #GtkPrintPages value
1400  *
1401  * Sets the value of %GTK_PRINT_SETTINGS_PRINT_PAGES.
1402  *
1403  * Since: 2.10
1404  */
1405 void
1406 gtk_print_settings_set_print_pages (GtkPrintSettings *settings,
1407                                     GtkPrintPages     pages)
1408 {
1409   const gchar *str;
1410
1411   switch (pages)
1412     {
1413     default:
1414     case GTK_PRINT_PAGES_ALL:
1415       str = "all";
1416       break;
1417     case GTK_PRINT_PAGES_CURRENT:
1418       str = "current";
1419       break;
1420     case GTK_PRINT_PAGES_SELECTION:
1421       str = "selection";
1422       break;
1423     case GTK_PRINT_PAGES_RANGES:
1424       str = "ranges";
1425       break;
1426     }
1427
1428   gtk_print_settings_set (settings, GTK_PRINT_SETTINGS_PRINT_PAGES, str);
1429 }
1430
1431 /**
1432  * gtk_print_settings_get_page_ranges:
1433  * @settings: a #GtkPrintSettings
1434  * @num_ranges: (out): return location for the length of the returned array
1435  *
1436  * Gets the value of %GTK_PRINT_SETTINGS_PAGE_RANGES.
1437  *
1438  * Return value: (array length=num_ranges) (transfer full): an array
1439  *     of #GtkPageRange<!-- -->s.  Use g_free() to free the array when
1440  *     it is no longer needed.
1441  *
1442  * Since: 2.10
1443  */
1444 GtkPageRange *
1445 gtk_print_settings_get_page_ranges (GtkPrintSettings *settings,
1446                                     gint             *num_ranges)
1447 {
1448   const gchar *val;
1449   gchar **range_strs;
1450   GtkPageRange *ranges;
1451   gint i, n;
1452
1453   val = gtk_print_settings_get (settings, GTK_PRINT_SETTINGS_PAGE_RANGES);
1454
1455   if (val == NULL)
1456     {
1457       *num_ranges = 0;
1458       return NULL;
1459     }
1460
1461   range_strs = g_strsplit (val, ",", 0);
1462
1463   for (i = 0; range_strs[i] != NULL; i++)
1464     ;
1465
1466   n = i;
1467
1468   ranges = g_new0 (GtkPageRange, n);
1469
1470   for (i = 0; i < n; i++)
1471     {
1472       gint start, end;
1473       gchar *str;
1474
1475       start = (gint)strtol (range_strs[i], &str, 10);
1476       end = start;
1477
1478       if (*str == '-')
1479         {
1480           str++;
1481           end = (gint)strtol (str, NULL, 10);
1482         }
1483
1484       ranges[i].start = start;
1485       ranges[i].end = end;
1486     }
1487
1488   g_strfreev (range_strs);
1489
1490   *num_ranges = n;
1491   return ranges;
1492 }
1493
1494 /**
1495  * gtk_print_settings_set_page_ranges:
1496  * @settings: a #GtkPrintSettings
1497  * @page_ranges: (array length=num_ranges): an array of #GtkPageRange<!-- -->s
1498  * @num_ranges: the length of @page_ranges
1499  *
1500  * Sets the value of %GTK_PRINT_SETTINGS_PAGE_RANGES.
1501  *
1502  * Since: 2.10
1503  */
1504 void
1505 gtk_print_settings_set_page_ranges  (GtkPrintSettings *settings,
1506                                      GtkPageRange     *page_ranges,
1507                                      gint              num_ranges)
1508 {
1509   GString *s;
1510   gint i;
1511
1512   s = g_string_new ("");
1513
1514   for (i = 0; i < num_ranges; i++)
1515     {
1516       if (page_ranges[i].start == page_ranges[i].end)
1517         g_string_append_printf (s, "%d", page_ranges[i].start);
1518       else
1519         g_string_append_printf (s, "%d-%d",
1520                                 page_ranges[i].start,
1521                                 page_ranges[i].end);
1522       if (i < num_ranges - 1)
1523         g_string_append (s, ",");
1524     }
1525
1526
1527   gtk_print_settings_set (settings, GTK_PRINT_SETTINGS_PAGE_RANGES,
1528                           s->str);
1529
1530   g_string_free (s, TRUE);
1531 }
1532
1533 /**
1534  * gtk_print_settings_get_default_source:
1535  * @settings: a #GtkPrintSettings
1536  *
1537  * Gets the value of %GTK_PRINT_SETTINGS_DEFAULT_SOURCE.
1538  *
1539  * Return value: the default source
1540  *
1541  * Since: 2.10
1542  */
1543 G_CONST_RETURN gchar *
1544 gtk_print_settings_get_default_source (GtkPrintSettings *settings)
1545 {
1546   return gtk_print_settings_get (settings, GTK_PRINT_SETTINGS_DEFAULT_SOURCE);
1547 }
1548
1549 /**
1550  * gtk_print_settings_set_default_source:
1551  * @settings: a #GtkPrintSettings
1552  * @default_source: the default source
1553  *
1554  * Sets the value of %GTK_PRINT_SETTINGS_DEFAULT_SOURCE.
1555  *
1556  * Since: 2.10
1557  */
1558 void
1559 gtk_print_settings_set_default_source (GtkPrintSettings *settings,
1560                                        const gchar      *default_source)
1561 {
1562   gtk_print_settings_set (settings, GTK_PRINT_SETTINGS_DEFAULT_SOURCE, default_source);
1563 }
1564
1565 /**
1566  * gtk_print_settings_get_media_type:
1567  * @settings: a #GtkPrintSettings
1568  *
1569  * Gets the value of %GTK_PRINT_SETTINGS_MEDIA_TYPE.
1570  *
1571  * The set of media types is defined in PWG 5101.1-2002 PWG.
1572  * <!-- FIXME link here -->
1573  *
1574  * Return value: the media type
1575  *
1576  * Since: 2.10
1577  */
1578 G_CONST_RETURN gchar *
1579 gtk_print_settings_get_media_type (GtkPrintSettings *settings)
1580 {
1581   return gtk_print_settings_get (settings, GTK_PRINT_SETTINGS_MEDIA_TYPE);
1582 }
1583
1584 /**
1585  * gtk_print_settings_set_media_type:
1586  * @settings: a #GtkPrintSettings
1587  * @media_type: the media type
1588  *
1589  * Sets the value of %GTK_PRINT_SETTINGS_MEDIA_TYPE.
1590  *
1591  * The set of media types is defined in PWG 5101.1-2002 PWG.
1592  * <!-- FIXME link here -->
1593  *
1594  * Since: 2.10
1595  */
1596 void
1597 gtk_print_settings_set_media_type (GtkPrintSettings *settings,
1598                                    const gchar      *media_type)
1599 {
1600   gtk_print_settings_set (settings, GTK_PRINT_SETTINGS_MEDIA_TYPE, media_type);
1601 }
1602
1603 /**
1604  * gtk_print_settings_get_dither:
1605  * @settings: a #GtkPrintSettings
1606  *
1607  * Gets the value of %GTK_PRINT_SETTINGS_DITHER.
1608  *
1609  * Return value: the dithering that is used
1610  *
1611  * Since: 2.10
1612  */
1613 G_CONST_RETURN gchar *
1614 gtk_print_settings_get_dither (GtkPrintSettings *settings)
1615 {
1616   return gtk_print_settings_get (settings, GTK_PRINT_SETTINGS_DITHER);
1617 }
1618
1619 /**
1620  * gtk_print_settings_set_dither:
1621  * @settings: a #GtkPrintSettings
1622  * @dither: the dithering that is used
1623  *
1624  * Sets the value of %GTK_PRINT_SETTINGS_DITHER.
1625  *
1626  * Since: 2.10
1627  */
1628 void
1629 gtk_print_settings_set_dither (GtkPrintSettings *settings,
1630                                const gchar      *dither)
1631 {
1632   gtk_print_settings_set (settings, GTK_PRINT_SETTINGS_DITHER, dither);
1633 }
1634
1635 /**
1636  * gtk_print_settings_get_finishings:
1637  * @settings: a #GtkPrintSettings
1638  *
1639  * Gets the value of %GTK_PRINT_SETTINGS_FINISHINGS.
1640  *
1641  * Return value: the finishings
1642  *
1643  * Since: 2.10
1644  */
1645 const gchar *
1646 gtk_print_settings_get_finishings (GtkPrintSettings *settings)
1647 {
1648   return gtk_print_settings_get (settings, GTK_PRINT_SETTINGS_FINISHINGS);
1649 }
1650
1651 /**
1652  * gtk_print_settings_set_finishings:
1653  * @settings: a #GtkPrintSettings
1654  * @finishings: the finishings
1655  *
1656  * Sets the value of %GTK_PRINT_SETTINGS_FINISHINGS.
1657  *
1658  * Since: 2.10
1659  */
1660 void
1661 gtk_print_settings_set_finishings (GtkPrintSettings *settings,
1662                                    const gchar      *finishings)
1663 {
1664   gtk_print_settings_set (settings, GTK_PRINT_SETTINGS_FINISHINGS, finishings);
1665 }
1666
1667 /**
1668  * gtk_print_settings_get_output_bin:
1669  * @settings: a #GtkPrintSettings
1670  *
1671  * Gets the value of %GTK_PRINT_SETTINGS_OUTPUT_BIN.
1672  *
1673  * Return value: the output bin
1674  *
1675  * Since: 2.10
1676  */
1677 G_CONST_RETURN gchar *
1678 gtk_print_settings_get_output_bin (GtkPrintSettings *settings)
1679 {
1680   return gtk_print_settings_get (settings, GTK_PRINT_SETTINGS_OUTPUT_BIN);
1681 }
1682
1683 /**
1684  * gtk_print_settings_set_output_bin:
1685  * @settings: a #GtkPrintSettings
1686  * @output_bin: the output bin
1687  *
1688  * Sets the value of %GTK_PRINT_SETTINGS_OUTPUT_BIN.
1689  *
1690  * Since: 2.10
1691  */
1692 void
1693 gtk_print_settings_set_output_bin (GtkPrintSettings *settings,
1694                                    const gchar      *output_bin)
1695 {
1696   gtk_print_settings_set (settings, GTK_PRINT_SETTINGS_OUTPUT_BIN, output_bin);
1697 }
1698
1699 /**
1700  * gtk_print_settings_load_file:
1701  * @settings: a #GtkPrintSettings
1702  * @file_name: (type filename): the filename to read the settings from
1703  * @error: (allow-none): return location for errors, or %NULL
1704  *
1705  * Reads the print settings from @file_name. If the file could not be loaded
1706  * then error is set to either a #GFileError or #GKeyFileError.
1707  * See gtk_print_settings_to_file().
1708  *
1709  * Return value: %TRUE on success
1710  *
1711  * Since: 2.14
1712  */
1713 gboolean
1714 gtk_print_settings_load_file (GtkPrintSettings *settings,
1715                               const gchar      *file_name,
1716                               GError          **error)
1717 {
1718   gboolean retval = FALSE;
1719   GKeyFile *key_file;
1720
1721   g_return_val_if_fail (GTK_IS_PRINT_SETTINGS (settings), FALSE);
1722   g_return_val_if_fail (file_name != NULL, FALSE);
1723
1724   key_file = g_key_file_new ();
1725
1726   if (g_key_file_load_from_file (key_file, file_name, 0, error) &&
1727       gtk_print_settings_load_key_file (settings, key_file, NULL, error))
1728     retval = TRUE;
1729
1730   g_key_file_free (key_file);
1731
1732   return retval;
1733 }
1734
1735 /**
1736  * gtk_print_settings_new_from_file:
1737  * @file_name: (type filename): the filename to read the settings from
1738  * @error: (allow-none): return location for errors, or %NULL
1739  *
1740  * Reads the print settings from @file_name. Returns a new #GtkPrintSettings
1741  * object with the restored settings, or %NULL if an error occurred. If the
1742  * file could not be loaded then error is set to either a #GFileError or
1743  * #GKeyFileError.  See gtk_print_settings_to_file().
1744  *
1745  * Return value: the restored #GtkPrintSettings
1746  *
1747  * Since: 2.12
1748  */
1749 GtkPrintSettings *
1750 gtk_print_settings_new_from_file (const gchar  *file_name,
1751                                   GError      **error)
1752 {
1753   GtkPrintSettings *settings = gtk_print_settings_new ();
1754
1755   if (!gtk_print_settings_load_file (settings, file_name, error))
1756     {
1757       g_object_unref (settings);
1758       settings = NULL;
1759     }
1760
1761   return settings;
1762 }
1763
1764 /**
1765  * gtk_print_settings_load_key_file:
1766  * @settings: a #GtkPrintSettings
1767  * @key_file: the #GKeyFile to retrieve the settings from
1768  * @group_name: (allow-none): the name of the group to use, or %NULL to use the default
1769  *     "Print Settings"
1770  * @error: (allow-none): return location for errors, or %NULL
1771  *
1772  * Reads the print settings from the group @group_name in @key_file. If the
1773  * file could not be loaded then error is set to either a #GFileError or
1774  * #GKeyFileError.
1775  *
1776  * Return value: %TRUE on success
1777  *
1778  * Since: 2.14
1779  */
1780 gboolean
1781 gtk_print_settings_load_key_file (GtkPrintSettings *settings,
1782                                   GKeyFile         *key_file,
1783                                   const gchar      *group_name,
1784                                   GError          **error)
1785 {
1786   gchar **keys;
1787   gsize n_keys, i;
1788   GError *err = NULL;
1789
1790   g_return_val_if_fail (GTK_IS_PRINT_SETTINGS (settings), FALSE);
1791   g_return_val_if_fail (key_file != NULL, FALSE);
1792
1793   if (!group_name)
1794     group_name = KEYFILE_GROUP_NAME;
1795
1796   keys = g_key_file_get_keys (key_file,
1797                               group_name,
1798                               &n_keys,
1799                               &err);
1800   if (err != NULL)
1801     {
1802       g_propagate_error (error, err);
1803       return FALSE;
1804     }
1805
1806   for (i = 0 ; i < n_keys; ++i)
1807     {
1808       gchar *value;
1809
1810       value = g_key_file_get_string (key_file,
1811                                      KEYFILE_GROUP_NAME,
1812                                      keys[i],
1813                                      NULL);
1814       if (!value)
1815         continue;
1816
1817       gtk_print_settings_set (settings, keys[i], value);
1818       g_free (value);
1819     }
1820
1821   g_strfreev (keys);
1822
1823   return TRUE;
1824 }
1825
1826 /**
1827  * gtk_print_settings_new_from_key_file:
1828  * @key_file: the #GKeyFile to retrieve the settings from
1829  * @group_name: (allow-none): the name of the group to use, or %NULL to use
1830  *     the default "Print Settings"
1831  * @error: (allow-none): return location for errors, or %NULL
1832  *
1833  * Reads the print settings from the group @group_name in @key_file.  Returns a
1834  * new #GtkPrintSettings object with the restored settings, or %NULL if an
1835  * error occurred. If the file could not be loaded then error is set to either
1836  * a #GFileError or #GKeyFileError.
1837  *
1838  * Return value: the restored #GtkPrintSettings
1839  *
1840  * Since: 2.12
1841  */
1842 GtkPrintSettings *
1843 gtk_print_settings_new_from_key_file (GKeyFile     *key_file,
1844                                       const gchar  *group_name,
1845                                       GError      **error)
1846 {
1847   GtkPrintSettings *settings = gtk_print_settings_new ();
1848
1849   if (!gtk_print_settings_load_key_file (settings, key_file,
1850                                          group_name, error))
1851     {
1852       g_object_unref (settings);
1853       settings = NULL;
1854     }
1855
1856   return settings;
1857 }
1858
1859 /**
1860  * gtk_print_settings_to_file:
1861  * @settings: a #GtkPrintSettings
1862  * @file_name: (type filename): the file to save to
1863  * @error: (allow-none): return location for errors, or %NULL
1864  *
1865  * This function saves the print settings from @settings to @file_name. If the
1866  * file could not be loaded then error is set to either a #GFileError or
1867  * #GKeyFileError.
1868  *
1869  * Return value: %TRUE on success
1870  *
1871  * Since: 2.12
1872  */
1873 gboolean
1874 gtk_print_settings_to_file (GtkPrintSettings  *settings,
1875                             const gchar       *file_name,
1876                             GError           **error)
1877 {
1878   GKeyFile *key_file;
1879   gboolean retval = FALSE;
1880   char *data = NULL;
1881   gsize len;
1882   GError *err = NULL;
1883
1884   g_return_val_if_fail (GTK_IS_PRINT_SETTINGS (settings), FALSE);
1885   g_return_val_if_fail (file_name != NULL, FALSE);
1886
1887   key_file = g_key_file_new ();
1888   gtk_print_settings_to_key_file (settings, key_file, NULL);
1889
1890   data = g_key_file_to_data (key_file, &len, &err);
1891   if (!data)
1892     goto out;
1893
1894   retval = g_file_set_contents (file_name, data, len, &err);
1895
1896 out:
1897   if (err != NULL)
1898     g_propagate_error (error, err);
1899
1900   g_key_file_free (key_file);
1901   g_free (data);
1902
1903   return retval;
1904 }
1905
1906 typedef struct {
1907   GKeyFile *key_file;
1908   const gchar *group_name;
1909 } SettingsData;
1910
1911 static void
1912 add_value_to_key_file (const gchar  *key,
1913                        const gchar  *value,
1914                        SettingsData *data)
1915 {
1916   g_key_file_set_string (data->key_file, data->group_name, key, value);
1917 }
1918
1919 /**
1920  * gtk_print_settings_to_key_file:
1921  * @settings: a #GtkPrintSettings
1922  * @key_file: the #GKeyFile to save the print settings to
1923  * @group_name: the group to add the settings to in @key_file, or
1924  *     %NULL to use the default "Print Settings"
1925  *
1926  * This function adds the print settings from @settings to @key_file.
1927  *
1928  * Since: 2.12
1929  */
1930 void
1931 gtk_print_settings_to_key_file (GtkPrintSettings  *settings,
1932                                 GKeyFile          *key_file,
1933                                 const gchar       *group_name)
1934 {
1935   SettingsData data;
1936
1937   g_return_if_fail (GTK_IS_PRINT_SETTINGS (settings));
1938   g_return_if_fail (key_file != NULL);
1939
1940   if (!group_name)
1941     group_name = KEYFILE_GROUP_NAME;
1942
1943   data.key_file = key_file;
1944   data.group_name = group_name;
1945
1946   gtk_print_settings_foreach (settings,
1947                               (GtkPrintSettingsFunc) add_value_to_key_file,
1948                               &data);
1949 }