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 (settings, GTK_PRINT_SETTINGS_NUMBER_UP);
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 (settings, GTK_PRINT_SETTINGS_RESOLUTION);
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 (settings, GTK_PRINT_SETTINGS_RESOLUTION_X);
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 (settings, GTK_PRINT_SETTINGS_RESOLUTION_Y);
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 (settings, GTK_PRINT_SETTINGS_PRINTER_LPI);
1285 }
1286
1287 /**
1288  * gtk_print_settings_set_printer_lpi:
1289  * @settings: a #GtkPrintSettings
1290  * @resolution: 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, "current") == 0)
1360     return GTK_PRINT_PAGES_CURRENT;
1361
1362   if (strcmp (val, "ranges") == 0)
1363     return GTK_PRINT_PAGES_RANGES;
1364
1365   return GTK_PRINT_PAGES_ALL;
1366 }
1367
1368 /**
1369  * gtk_print_settings_set_print_pages:
1370  * @settings: a #GtkPrintSettings
1371  * @pages: a #GtkPrintPages value
1372  *
1373  * Sets the value of %GTK_PRINT_SETTINGS_PRINT_PAGES.
1374  *
1375  * Since: 2.10
1376  */
1377 void
1378 gtk_print_settings_set_print_pages (GtkPrintSettings *settings,
1379                                     GtkPrintPages     pages)
1380 {
1381   const gchar *str;
1382
1383   switch (pages)
1384     {
1385     default:
1386     case GTK_PRINT_PAGES_ALL:
1387       str = "all";
1388       break;
1389     case GTK_PRINT_PAGES_CURRENT:
1390       str = "current";
1391       break;
1392     case GTK_PRINT_PAGES_RANGES:
1393       str = "ranges";
1394       break;
1395     }
1396
1397   gtk_print_settings_set (settings, GTK_PRINT_SETTINGS_PRINT_PAGES, str);
1398 }
1399
1400 /**
1401  * gtk_print_settings_get_page_ranges:
1402  * @settings: a #GtkPrintSettings
1403  * @num_ranges: return location for the length of the returned array
1404  *
1405  * Gets the value of %GTK_PRINT_SETTINGS_PAGE_RANGES.
1406  *
1407  * Return value: an array of #GtkPageRange<!-- -->s. Use g_free()
1408  *   to free the array when it is no longer needed.
1409  *
1410  * Since: 2.10
1411  */
1412 GtkPageRange *
1413 gtk_print_settings_get_page_ranges (GtkPrintSettings *settings,
1414                                     gint             *num_ranges)
1415 {
1416   const gchar *val;
1417   gchar **range_strs;
1418   GtkPageRange *ranges;
1419   gint i, n;
1420
1421   val = gtk_print_settings_get (settings, GTK_PRINT_SETTINGS_PAGE_RANGES);
1422
1423   if (val == NULL)
1424     {
1425       *num_ranges = 0;
1426       return NULL;
1427     }
1428
1429   range_strs = g_strsplit (val, ",", 0);
1430
1431   for (i = 0; range_strs[i] != NULL; i++)
1432     ;
1433
1434   n = i;
1435
1436   ranges = g_new0 (GtkPageRange, n);
1437
1438   for (i = 0; i < n; i++)
1439     {
1440       gint start, end;
1441       gchar *str;
1442
1443       start = (gint)strtol (range_strs[i], &str, 10);
1444       end = start;
1445
1446       if (*str == '-')
1447         {
1448           str++;
1449           end = (gint)strtol (str, NULL, 10);
1450         }
1451
1452       ranges[i].start = start;
1453       ranges[i].end = end;
1454     }
1455
1456   g_strfreev (range_strs);
1457
1458   *num_ranges = n;
1459   return ranges;
1460 }
1461
1462 /**
1463  * gtk_print_settings_set_page_ranges:
1464  * @settings: a #GtkPrintSettings
1465  * @page_ranges: an array of #GtkPageRange<!-- -->s
1466  * @num_ranges: the length of @page_ranges
1467  *
1468  * Sets the value of %GTK_PRINT_SETTINGS_PAGE_RANGES.
1469  *
1470  * Since: 2.10
1471  */
1472 void
1473 gtk_print_settings_set_page_ranges  (GtkPrintSettings *settings,
1474                                      GtkPageRange     *page_ranges,
1475                                      gint              num_ranges)
1476 {
1477   GString *s;
1478   gint i;
1479
1480   s = g_string_new ("");
1481
1482   for (i = 0; i < num_ranges; i++)
1483     {
1484       if (page_ranges[i].start == page_ranges[i].end)
1485         g_string_append_printf (s, "%d", page_ranges[i].start);
1486       else
1487         g_string_append_printf (s, "%d-%d",
1488                                 page_ranges[i].start,
1489                                 page_ranges[i].end);
1490       if (i < num_ranges - 1)
1491         g_string_append (s, ",");
1492     }
1493
1494
1495   gtk_print_settings_set (settings, GTK_PRINT_SETTINGS_PAGE_RANGES,
1496                           s->str);
1497
1498   g_string_free (s, TRUE);
1499 }
1500
1501 /**
1502  * gtk_print_settings_get_default_source:
1503  * @settings: a #GtkPrintSettings
1504  *
1505  * Gets the value of %GTK_PRINT_SETTINGS_DEFAULT_SOURCE.
1506  *
1507  * Return value: the default source
1508  *
1509  * Since: 2.10
1510  */
1511 G_CONST_RETURN gchar *
1512 gtk_print_settings_get_default_source (GtkPrintSettings *settings)
1513 {
1514   return gtk_print_settings_get (settings, GTK_PRINT_SETTINGS_DEFAULT_SOURCE);
1515 }
1516
1517 /**
1518  * gtk_print_settings_set_default_source:
1519  * @settings: a #GtkPrintSettings
1520  * @default_source: the default source
1521  *
1522  * Sets the value of %GTK_PRINT_SETTINGS_DEFAULT_SOURCE.
1523  *
1524  * Since: 2.10
1525  */
1526 void
1527 gtk_print_settings_set_default_source (GtkPrintSettings *settings,
1528                                        const gchar      *default_source)
1529 {
1530   gtk_print_settings_set (settings, GTK_PRINT_SETTINGS_DEFAULT_SOURCE, default_source);
1531 }
1532
1533 /**
1534  * gtk_print_settings_get_media_type:
1535  * @settings: a #GtkPrintSettings
1536  *
1537  * Gets the value of %GTK_PRINT_SETTINGS_MEDIA_TYPE.
1538  *
1539  * The set of media types is defined in PWG 5101.1-2002 PWG.
1540  * <!-- FIXME link here -->
1541  *
1542  * Return value: the media type
1543  *
1544  * Since: 2.10
1545  */
1546 G_CONST_RETURN gchar *
1547 gtk_print_settings_get_media_type (GtkPrintSettings *settings)
1548 {
1549   return gtk_print_settings_get (settings, GTK_PRINT_SETTINGS_MEDIA_TYPE);
1550 }
1551
1552 /**
1553  * gtk_print_settings_set_media_type:
1554  * @settings: a #GtkPrintSettings
1555  * @media_type: the media type
1556  *
1557  * Sets the value of %GTK_PRINT_SETTINGS_MEDIA_TYPE.
1558  *
1559  * The set of media types is defined in PWG 5101.1-2002 PWG.
1560  * <!-- FIXME link here -->
1561  *
1562  * Since: 2.10
1563  */
1564 void
1565 gtk_print_settings_set_media_type (GtkPrintSettings *settings,
1566                                    const gchar      *media_type)
1567 {
1568   gtk_print_settings_set (settings, GTK_PRINT_SETTINGS_MEDIA_TYPE, media_type);
1569 }
1570
1571 /**
1572  * gtk_print_settings_get_dither:
1573  * @settings: a #GtkPrintSettings
1574  *
1575  * Gets the value of %GTK_PRINT_SETTINGS_DITHER.
1576  *
1577  * Return value: the dithering that is used
1578  *
1579  * Since: 2.10
1580  */
1581 G_CONST_RETURN gchar *
1582 gtk_print_settings_get_dither (GtkPrintSettings *settings)
1583 {
1584   return gtk_print_settings_get (settings, GTK_PRINT_SETTINGS_DITHER);
1585 }
1586
1587 /**
1588  * gtk_print_settings_set_dither:
1589  * @settings: a #GtkPrintSettings
1590  * @dither: the dithering that is used
1591  *
1592  * Sets the value of %GTK_PRINT_SETTINGS_DITHER.
1593  *
1594  * Since: 2.10
1595  */
1596 void
1597 gtk_print_settings_set_dither (GtkPrintSettings *settings,
1598                                const gchar      *dither)
1599 {
1600   gtk_print_settings_set (settings, GTK_PRINT_SETTINGS_DITHER, dither);
1601 }
1602
1603 /**
1604  * gtk_print_settings_get_finishings:
1605  * @settings: a #GtkPrintSettings
1606  *
1607  * Gets the value of %GTK_PRINT_SETTINGS_FINISHINGS.
1608  *
1609  * Return value: the finishings
1610  *
1611  * Since: 2.10
1612  */
1613 const gchar *
1614 gtk_print_settings_get_finishings (GtkPrintSettings *settings)
1615 {
1616   return gtk_print_settings_get (settings, GTK_PRINT_SETTINGS_FINISHINGS);
1617 }
1618
1619 /**
1620  * gtk_print_settings_set_finishings:
1621  * @settings: a #GtkPrintSettings
1622  * @finishings: the finishings
1623  *
1624  * Sets the value of %GTK_PRINT_SETTINGS_FINISHINGS.
1625  *
1626  * Since: 2.10
1627  */
1628 void
1629 gtk_print_settings_set_finishings (GtkPrintSettings *settings,
1630                                    const gchar      *finishings)
1631 {
1632   gtk_print_settings_set (settings, GTK_PRINT_SETTINGS_FINISHINGS, finishings);
1633 }
1634
1635 /**
1636  * gtk_print_settings_get_output_bin:
1637  * @settings: a #GtkPrintSettings
1638  *
1639  * Gets the value of %GTK_PRINT_SETTINGS_OUTPUT_BIN.
1640  *
1641  * Return value: the output bin
1642  *
1643  * Since: 2.10
1644  */
1645 G_CONST_RETURN gchar *
1646 gtk_print_settings_get_output_bin (GtkPrintSettings *settings)
1647 {
1648   return gtk_print_settings_get (settings, GTK_PRINT_SETTINGS_OUTPUT_BIN);
1649 }
1650
1651 /**
1652  * gtk_print_settings_set_output_bin:
1653  * @settings: a #GtkPrintSettings
1654  * @output_bin: the output bin
1655  *
1656  * Sets the value of %GTK_PRINT_SETTINGS_OUTPUT_BIN.
1657  *
1658  * Since: 2.10
1659  */
1660 void
1661 gtk_print_settings_set_output_bin (GtkPrintSettings *settings,
1662                                    const gchar      *output_bin)
1663 {
1664   gtk_print_settings_set (settings, GTK_PRINT_SETTINGS_OUTPUT_BIN, output_bin);
1665 }
1666
1667 /**
1668  * gtk_print_settings_load_file:
1669  * @settings: a #GtkPrintSettings
1670  * @file_name: the filename to read the settings from
1671  * @error: return location for errors, or %NULL
1672  *
1673  * Reads the print settings from @file_name.
1674  * See gtk_print_settings_to_file().
1675  *
1676  * Return value: %TRUE on success
1677  *
1678  * Since: 2.14
1679  */
1680 gboolean
1681 gtk_print_settings_load_file (GtkPrintSettings *settings,
1682                               const gchar      *file_name,
1683                               GError          **error)
1684 {
1685   gboolean retval = FALSE;
1686   GKeyFile *key_file;
1687
1688   g_return_val_if_fail (GTK_IS_PRINT_SETTINGS (settings), FALSE);
1689   g_return_val_if_fail (file_name != NULL, FALSE);
1690
1691   key_file = g_key_file_new ();
1692
1693   if (g_key_file_load_from_file (key_file, file_name, 0, error) &&
1694       gtk_print_settings_load_key_file (settings, key_file, NULL, error))
1695     retval = TRUE;
1696
1697   g_key_file_free (key_file);
1698
1699   return retval;
1700 }
1701
1702 /**
1703  * gtk_print_settings_new_from_file:
1704  * @file_name: the filename to read the settings from
1705  * @error: return location for errors, or %NULL
1706  *
1707  * Reads the print settings from @file_name. Returns a new #GtkPrintSettings
1708  * object with the restored settings, or %NULL if an error occurred.
1709  * See gtk_print_settings_to_file().
1710  *
1711  * Return value: the restored #GtkPrintSettings
1712  *
1713  * Since: 2.12
1714  */
1715 GtkPrintSettings *
1716 gtk_print_settings_new_from_file (const gchar  *file_name,
1717                                   GError      **error)
1718 {
1719   GtkPrintSettings *settings = gtk_print_settings_new ();
1720
1721   if (!gtk_print_settings_load_file (settings, file_name, error))
1722     {
1723       g_object_unref (settings);
1724       settings = NULL;
1725     }
1726
1727   return settings;
1728 }
1729
1730 /**
1731  * gtk_print_settings_load_key_file:
1732  * @settings: a #GtkPrintSettings
1733  * @key_file: the #GKeyFile to retrieve the settings from
1734  * @group_name: the name of the group to use, or %NULL to use the default
1735  *     "Print Settings"
1736  * @error: return location for errors, or %NULL
1737  *
1738  * Reads the print settings from the group @group_name in @key_file.
1739  *
1740  * Return value: %TRUE on success
1741  *
1742  * Since: 2.14
1743  */
1744 gboolean
1745 gtk_print_settings_load_key_file (GtkPrintSettings *settings,
1746                                   GKeyFile         *key_file,
1747                                   const gchar      *group_name,
1748                                   GError          **error)
1749 {
1750   gchar **keys;
1751   gsize n_keys, i;
1752   GError *err = NULL;
1753
1754   g_return_val_if_fail (GTK_IS_PRINT_SETTINGS (settings), FALSE);
1755   g_return_val_if_fail (key_file != NULL, FALSE);
1756
1757   if (!group_name)
1758     group_name = KEYFILE_GROUP_NAME;
1759
1760   keys = g_key_file_get_keys (key_file,
1761                               group_name,
1762                               &n_keys,
1763                               &err);
1764   if (err != NULL)
1765     {
1766       g_propagate_error (error, err);
1767       return FALSE;
1768     }
1769
1770   for (i = 0 ; i < n_keys; ++i)
1771     {
1772       gchar *value;
1773
1774       value = g_key_file_get_string (key_file,
1775                                      KEYFILE_GROUP_NAME,
1776                                      keys[i],
1777                                      NULL);
1778       if (!value)
1779         continue;
1780
1781       gtk_print_settings_set (settings, keys[i], value);
1782       g_free (value);
1783     }
1784
1785   g_strfreev (keys);
1786
1787   return TRUE;
1788 }
1789
1790 /**
1791  * gtk_print_settings_new_from_key_file:
1792  * @key_file: the #GKeyFile to retrieve the settings from
1793  * @group_name: the name of the group to use, or %NULL to use
1794  *     the default "Print Settings"
1795  * @error: return location for errors, or %NULL
1796  *
1797  * Reads the print settings from the group @group_name in @key_file.
1798  * Returns a new #GtkPrintSettings object with the restored settings,
1799  * or %NULL if an error occurred.
1800  *
1801  * Return value: the restored #GtkPrintSettings
1802  *
1803  * Since: 2.12
1804  */
1805 GtkPrintSettings *
1806 gtk_print_settings_new_from_key_file (GKeyFile     *key_file,
1807                                       const gchar  *group_name,
1808                                       GError      **error)
1809 {
1810   GtkPrintSettings *settings = gtk_print_settings_new ();
1811
1812   if (!gtk_print_settings_load_key_file (settings, key_file,
1813                                          group_name, error))
1814     {
1815       g_object_unref (settings);
1816       settings = NULL;
1817     }
1818
1819   return settings;
1820 }
1821
1822 /**
1823  * gtk_print_settings_to_file:
1824  * @settings: a #GtkPrintSettings
1825  * @file_name: the file to save to
1826  * @error: return location for errors, or %NULL
1827  *
1828  * This function saves the print settings from @settings to @file_name.
1829  *
1830  * Return value: %TRUE on success
1831  *
1832  * Since: 2.12
1833  */
1834 gboolean
1835 gtk_print_settings_to_file (GtkPrintSettings  *settings,
1836                             const gchar       *file_name,
1837                             GError           **error)
1838 {
1839   GKeyFile *key_file;
1840   gboolean retval = FALSE;
1841   char *data = NULL;
1842   gsize len;
1843   GError *err = NULL;
1844
1845   g_return_val_if_fail (GTK_IS_PRINT_SETTINGS (settings), FALSE);
1846   g_return_val_if_fail (file_name != NULL, FALSE);
1847
1848   key_file = g_key_file_new ();
1849   gtk_print_settings_to_key_file (settings, key_file, NULL);
1850
1851   data = g_key_file_to_data (key_file, &len, &err);
1852   if (!data)
1853     goto out;
1854
1855   retval = g_file_set_contents (file_name, data, len, &err);
1856
1857 out:
1858   if (err != NULL)
1859     g_propagate_error (error, err);
1860
1861   g_key_file_free (key_file);
1862   g_free (data);
1863
1864   return retval;
1865 }
1866
1867 typedef struct {
1868   GKeyFile *key_file;
1869   const gchar *group_name;
1870 } SettingsData;
1871
1872 static void
1873 add_value_to_key_file (const gchar  *key,
1874                        const gchar  *value,
1875                        SettingsData *data)
1876 {
1877   g_key_file_set_string (data->key_file, data->group_name, key, value);
1878 }
1879
1880 /**
1881  * gtk_print_settings_to_key_file:
1882  * @settings: a #GtkPrintSettings
1883  * @key_file: the #GKeyFile to save the print settings to
1884  * @group_name: the group to add the settings to in @key_file, or
1885  *     %NULL to use the default "Print Settings"
1886  *
1887  * This function adds the print settings from @settings to @key_file.
1888  *
1889  * Since: 2.12
1890  */
1891 void
1892 gtk_print_settings_to_key_file (GtkPrintSettings  *settings,
1893                                 GKeyFile          *key_file,
1894                                 const gchar       *group_name)
1895 {
1896   SettingsData data;
1897
1898   g_return_if_fail (GTK_IS_PRINT_SETTINGS (settings));
1899   g_return_if_fail (key_file != NULL);
1900
1901   if (!group_name)
1902     group_name = KEYFILE_GROUP_NAME;
1903
1904   data.key_file = key_file;
1905   data.group_name = group_name;
1906
1907   gtk_print_settings_foreach (settings,
1908                               (GtkPrintSettingsFunc) add_value_to_key_file,
1909                               &data);
1910 }
1911
1912
1913 #define __GTK_PRINT_SETTINGS_C__
1914 #include "gtkaliasdef.c"