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