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