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