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

   1 /* GTK - The GTK+ 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 "gtkprintsettings.h"
  26 #include "gtkprintutils.h"
  27 #include "gtkalias.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: 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 (val != NULL && strcmp (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 (val != NULL && strcmp (val, "true") == 0)
 266     return TRUE;
 267
 268   if (val != NULL && strcmp (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: 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_n_copies:
1043  * @settings: a #GtkPrintSettings
1044  *
1045  * Gets the value of %GTK_PRINT_SETTINGS_N_COPIES.
1046  *
1047  * Return value: the number of copies to print
1048  *
1049  * Since: 2.10
1050  */
1051 gint
1052 gtk_print_settings_get_n_copies (GtkPrintSettings *settings)
1053 {
1054   return gtk_print_settings_get_int_with_default (settings, GTK_PRINT_SETTINGS_N_COPIES, 1);
1055 }
1056
1057 /**
1058  * gtk_print_settings_set_n_copies:
1059  * @settings: a #GtkPrintSettings
1060  * @num_copies: the number of copies
1061  *
1062  * Sets the value of %GTK_PRINT_SETTINGS_N_COPIES.
1063  *
1064  * Since: 2.10
1065  */
1066 void
1067 gtk_print_settings_set_n_copies (GtkPrintSettings *settings,
1068                                  gint              num_copies)
1069 {
1070   gtk_print_settings_set_int (settings, GTK_PRINT_SETTINGS_N_COPIES,
1071                               num_copies);
1072 }
1073
1074 /**
1075  * gtk_print_settings_get_number_up:
1076  * @settings: a #GtkPrintSettings
1077  *
1078  * Gets the value of %GTK_PRINT_SETTINGS_NUMBER_UP.
1079  *
1080  * Return value: the number of pages per sheet
1081  *
1082  * Since: 2.10
1083  */
1084 gint
1085 gtk_print_settings_get_number_up (GtkPrintSettings *settings)
1086 {
1087   return gtk_print_settings_get_int (settings, GTK_PRINT_SETTINGS_NUMBER_UP);
1088 }
1089
1090 /**
1091  * gtk_print_settings_set_number_up:
1092  * @settings: a #GtkPrintSettings
1093  * @number_up: the number of pages per sheet
1094  *
1095  * Sets the value of %GTK_PRINT_SETTINGS_NUMBER_UP.
1096  *
1097  * Since: 2.10
1098  */
1099 void
1100 gtk_print_settings_set_number_up (GtkPrintSettings *settings,
1101                                   gint              number_up)
1102 {
1103   gtk_print_settings_set_int (settings, GTK_PRINT_SETTINGS_NUMBER_UP,
1104                                 number_up);
1105 }
1106
1107 /**
1108  * gtk_print_settings_get_resolution:
1109  * @settings: a #GtkPrintSettings
1110  *
1111  * Gets the value of %GTK_PRINT_SETTINGS_RESOLUTION.
1112  *
1113  * Return value: the resolution in dpi
1114  *
1115  * Since: 2.10
1116  */
1117 gint
1118 gtk_print_settings_get_resolution (GtkPrintSettings *settings)
1119 {
1120   return gtk_print_settings_get_int (settings, GTK_PRINT_SETTINGS_RESOLUTION);
1121 }
1122
1123 /**
1124  * gtk_print_settings_set_resolution:
1125  * @settings: a #GtkPrintSettings
1126  * @resolution: the resolution in dpi
1127  *
1128  * Sets the value of %GTK_PRINT_SETTINGS_RESOLUTION.
1129  *
1130  * Since: 2.10
1131  */
1132 void
1133 gtk_print_settings_set_resolution (GtkPrintSettings *settings,
1134                                    gint              resolution)
1135 {
1136   gtk_print_settings_set_int (settings, GTK_PRINT_SETTINGS_RESOLUTION,
1137                               resolution);
1138 }
1139
1140 /**
1141  * gtk_print_settings_get_scale:
1142  * @settings: a #GtkPrintSettings
1143  *
1144  * Gets the value of %GTK_PRINT_SETTINGS_SCALE.
1145  *
1146  * Return value: the scale in percent
1147  *
1148  * Since: 2.10
1149  */
1150 gdouble
1151 gtk_print_settings_get_scale (GtkPrintSettings *settings)
1152 {
1153   return gtk_print_settings_get_double_with_default (settings,
1154                                                      GTK_PRINT_SETTINGS_SCALE,
1155                                                      100.0);
1156 }
1157
1158 /**
1159  * gtk_print_settings_set_scale:
1160  * @settings: a #GtkPrintSettings
1161  * @scale: the scale in percent
1162  *
1163  * Sets the value of %GTK_PRINT_SETTINGS_SCALE.
1164  *
1165  * Since: 2.10
1166  */
1167 void
1168 gtk_print_settings_set_scale (GtkPrintSettings *settings,
1169                               gdouble           scale)
1170 {
1171   gtk_print_settings_set_double (settings, GTK_PRINT_SETTINGS_SCALE,
1172                                  scale);
1173 }
1174
1175 /**
1176  * gtk_print_settings_get_print_pages:
1177  * @settings: a #GtkPrintSettings
1178  *
1179  * Gets the value of %GTK_PRINT_SETTINGS_PRINT_PAGES.
1180  *
1181  * Return value: which pages to print
1182  *
1183  * Since: 2.10
1184  */
1185 GtkPrintPages
1186 gtk_print_settings_get_print_pages (GtkPrintSettings *settings)
1187 {
1188   const gchar *val;
1189
1190   val = gtk_print_settings_get (settings, GTK_PRINT_SETTINGS_PRINT_PAGES);
1191
1192   if (val == NULL || (strcmp (val, "all") == 0))
1193     return GTK_PRINT_PAGES_ALL;
1194
1195   if (strcmp (val, "current") == 0)
1196     return GTK_PRINT_PAGES_CURRENT;
1197
1198   if (strcmp (val, "ranges") == 0)
1199     return GTK_PRINT_PAGES_RANGES;
1200
1201   return GTK_PRINT_PAGES_ALL;
1202 }
1203
1204 /**
1205  * gtk_print_settings_set_print_pages:
1206  * @settings: a #GtkPrintSettings
1207  * @pages: a #GtkPrintPages value
1208  *
1209  * Sets the value of %GTK_PRINT_SETTINGS_PRINT_PAGES.
1210  *
1211  * Since: 2.10
1212  */
1213 void
1214 gtk_print_settings_set_print_pages (GtkPrintSettings *settings,
1215                                     GtkPrintPages     pages)
1216 {
1217   const gchar *str;
1218
1219   switch (pages)
1220     {
1221     default:
1222     case GTK_PRINT_PAGES_ALL:
1223       str = "all";
1224       break;
1225     case GTK_PRINT_PAGES_CURRENT:
1226       str = "current";
1227       break;
1228     case GTK_PRINT_PAGES_RANGES:
1229       str = "ranges";
1230       break;
1231     }
1232
1233   gtk_print_settings_set (settings, GTK_PRINT_SETTINGS_PRINT_PAGES, str);
1234 }
1235
1236 /**
1237  * gtk_print_settings_get_page_ranges:
1238  * @settings: a #GtkPrintSettings
1239  * @num_ranges: return location for the length of the returned array
1240  *
1241  * Gets the value of %GTK_PRINT_SETTINGS_PAGE_RANGES.
1242  *
1243  * Return value: an array of #GtkPageRange<!-- -->s. Use g_free()
1244  *   to free the array when it is no longer needed.
1245  *
1246  * Since: 2.10
1247  */
1248 GtkPageRange *
1249 gtk_print_settings_get_page_ranges (GtkPrintSettings *settings,
1250                                     gint             *num_ranges)
1251 {
1252   const gchar *val;
1253   gchar **range_strs;
1254   GtkPageRange *ranges;
1255   gint i, n;
1256
1257   val = gtk_print_settings_get (settings, GTK_PRINT_SETTINGS_PAGE_RANGES);
1258
1259   if (val == NULL)
1260     {
1261       *num_ranges = 0;
1262       return NULL;
1263     }
1264
1265   range_strs = g_strsplit (val, ",", 0);
1266
1267   for (i = 0; range_strs[i] != NULL; i++)
1268     ;
1269
1270   n = i;
1271
1272   ranges = g_new0 (GtkPageRange, n);
1273
1274   for (i = 0; i < n; i++)
1275     {
1276       gint start, end;
1277       gchar *str;
1278
1279       start = (gint)strtol (range_strs[i], &str, 10);
1280       end = start;
1281
1282       if (*str == '-')
1283         {
1284           str++;
1285           end = (gint)strtol (str, NULL, 10);
1286         }
1287
1288       ranges[i].start = start;
1289       ranges[i].end = end;
1290     }
1291
1292   g_strfreev (range_strs);
1293
1294   *num_ranges = n;
1295   return ranges;
1296 }
1297
1298 /**
1299  * gtk_print_settings_set_page_ranges:
1300  * @settings: a #GtkPrintSettings
1301  * @page_ranges: an array of #GtkPageRange<!-- -->s
1302  * @num_ranges: the length of @page_ranges
1303  *
1304  * Sets the value of %GTK_PRINT_SETTINGS_PAGE_RANGES.
1305  *
1306  * Since: 2.10
1307  */
1308 void
1309 gtk_print_settings_set_page_ranges  (GtkPrintSettings *settings,
1310                                      GtkPageRange     *page_ranges,
1311                                      gint              num_ranges)
1312 {
1313   GString *s;
1314   gint i;
1315
1316   s = g_string_new ("");
1317
1318   for (i = 0; i < num_ranges; i++)
1319     {
1320       if (page_ranges[i].start == page_ranges[i].end)
1321         g_string_append_printf (s, "%d", page_ranges[i].start);
1322       else
1323         g_string_append_printf (s, "%d-%d",
1324                                 page_ranges[i].start,
1325                                 page_ranges[i].end);
1326       if (i < num_ranges - 1)
1327         g_string_append (s, ",");
1328     }
1329
1330
1331   gtk_print_settings_set (settings, GTK_PRINT_SETTINGS_PAGE_RANGES,
1332                           s->str);
1333
1334   g_string_free (s, TRUE);
1335 }
1336
1337 /**
1338  * gtk_print_settings_get_default_source:
1339  * @settings: a #GtkPrintSettings
1340  *
1341  * Gets the value of %GTK_PRINT_SETTINGS_DEFAULT_SOURCE.
1342  *
1343  * Return value: the default source
1344  *
1345  * Since: 2.10
1346  */
1347 G_CONST_RETURN gchar *
1348 gtk_print_settings_get_default_source (GtkPrintSettings *settings)
1349 {
1350   return gtk_print_settings_get (settings, GTK_PRINT_SETTINGS_DEFAULT_SOURCE);
1351 }
1352
1353 /**
1354  * gtk_print_settings_set_default_source:
1355  * @settings: a #GtkPrintSettings
1356  * @default_source: the default source
1357  *
1358  * Sets the value of %GTK_PRINT_SETTINGS_DEFAULT_SOURCE.
1359  *
1360  * Since: 2.10
1361  */
1362 void
1363 gtk_print_settings_set_default_source (GtkPrintSettings *settings,
1364                                        const gchar      *default_source)
1365 {
1366   gtk_print_settings_set (settings, GTK_PRINT_SETTINGS_DEFAULT_SOURCE, default_source);
1367 }
1368
1369 /**
1370  * gtk_print_settings_get_media_type:
1371  * @settings: a #GtkPrintSettings
1372  *
1373  * Gets the value of %GTK_PRINT_SETTINGS_MEDIA_TYPE.
1374  *
1375  * The set of media types is defined in PWG 5101.1-2002 PWG.
1376  * <!-- FIXME link here -->
1377  *
1378  * Return value: the media type
1379  *
1380  * Since: 2.10
1381  */
1382 G_CONST_RETURN gchar *
1383 gtk_print_settings_get_media_type (GtkPrintSettings *settings)
1384 {
1385   return gtk_print_settings_get (settings, GTK_PRINT_SETTINGS_MEDIA_TYPE);
1386 }
1387
1388 /**
1389  * gtk_print_settings_set_media_type:
1390  * @settings: a #GtkPrintSettings
1391  * @media_type: the media type
1392  *
1393  * Sets the value of %GTK_PRINT_SETTINGS_MEDIA_TYPE.
1394  *
1395  * The set of media types is defined in PWG 5101.1-2002 PWG.
1396  * <!-- FIXME link here -->
1397  *
1398  * Since: 2.10
1399  */
1400 void
1401 gtk_print_settings_set_media_type (GtkPrintSettings *settings,
1402                                    const gchar      *media_type)
1403 {
1404   gtk_print_settings_set (settings, GTK_PRINT_SETTINGS_MEDIA_TYPE, media_type);
1405 }
1406
1407 /**
1408  * gtk_print_settings_get_dither:
1409  * @settings: a #GtkPrintSettings
1410  *
1411  * Gets the value of %GTK_PRINT_SETTINGS_DITHER.
1412  *
1413  * Return value: the dithering that is used
1414  *
1415  * Since: 2.10
1416  */
1417 G_CONST_RETURN gchar *
1418 gtk_print_settings_get_dither (GtkPrintSettings *settings)
1419 {
1420   return gtk_print_settings_get (settings, GTK_PRINT_SETTINGS_DITHER);
1421 }
1422
1423 /**
1424  * gtk_print_settings_set_dither:
1425  * @settings: a #GtkPrintSettings
1426  * @dither: the dithering that is used
1427  *
1428  * Sets the value of %GTK_PRINT_SETTINGS_DITHER.
1429  *
1430  * Since: 2.10
1431  */
1432 void
1433 gtk_print_settings_set_dither (GtkPrintSettings *settings,
1434                                const gchar      *dither)
1435 {
1436   gtk_print_settings_set (settings, GTK_PRINT_SETTINGS_DITHER, dither);
1437 }
1438
1439 /**
1440  * gtk_print_settings_get_finishings:
1441  * @settings: a #GtkPrintSettings
1442  *
1443  * Gets the value of %GTK_PRINT_SETTINGS_FINISHINGS.
1444  *
1445  * Return value: the finishings
1446  *
1447  * Since: 2.10
1448  */
1449 const gchar *
1450 gtk_print_settings_get_finishings (GtkPrintSettings *settings)
1451 {
1452   return gtk_print_settings_get (settings, GTK_PRINT_SETTINGS_FINISHINGS);
1453 }
1454
1455 /**
1456  * gtk_print_settings_set_finishings:
1457  * @settings: a #GtkPrintSettings
1458  * @finishings: the finishings
1459  *
1460  * Sets the value of %GTK_PRINT_SETTINGS_FINISHINGS.
1461  *
1462  * Since: 2.10
1463  */
1464 void
1465 gtk_print_settings_set_finishings (GtkPrintSettings *settings,
1466                                    const gchar      *finishings)
1467 {
1468   gtk_print_settings_set (settings, GTK_PRINT_SETTINGS_FINISHINGS, finishings);
1469 }
1470
1471 /**
1472  * gtk_print_settings_get_output_bin:
1473  * @settings: a #GtkPrintSettings
1474  *
1475  * Gets the value of %GTK_PRINT_SETTINGS_OUTPUT_BIN.
1476  *
1477  * Return value: the output bin
1478  *
1479  * Since: 2.10
1480  */
1481 G_CONST_RETURN gchar *
1482 gtk_print_settings_get_output_bin (GtkPrintSettings *settings)
1483 {
1484   return gtk_print_settings_get (settings, GTK_PRINT_SETTINGS_OUTPUT_BIN);
1485 }
1486
1487 /**
1488  * gtk_print_settings_set_output_bin:
1489  * @settings: a #GtkPrintSettings
1490  * @output_bin: the output bin
1491  *
1492  * Sets the value of %GTK_PRINT_SETTINGS_OUTPUT_BIN.
1493  *
1494  * Since: 2.10
1495  */
1496 void
1497 gtk_print_settings_set_output_bin (GtkPrintSettings *settings,
1498                                    const gchar      *output_bin)
1499 {
1500   gtk_print_settings_set (settings, GTK_PRINT_SETTINGS_OUTPUT_BIN, output_bin);
1501 }
1502
1503 /**
1504  * gtk_print_settings_load_file:
1505  * @settings: a #GtkPrintSettings
1506  * @file_name: the filename to read the settings from
1507  * @error: return location for errors, or %NULL
1508  *
1509  * Reads the print settings from @file_name.
1510  * See gtk_print_settings_to_file().
1511  *
1512  * Return value: %TRUE on success
1513  *
1514  * Since: 2.14
1515  */
1516 gboolean
1517 gtk_print_settings_load_file (GtkPrintSettings *settings,
1518                               const gchar      *file_name,
1519                               GError          **error)
1520 {
1521   gboolean retval = FALSE;
1522   GKeyFile *key_file;
1523
1524   g_return_val_if_fail (GTK_IS_PRINT_SETTINGS (settings), FALSE);
1525   g_return_val_if_fail (file_name != NULL, FALSE);
1526
1527   key_file = g_key_file_new ();
1528
1529   if (g_key_file_load_from_file (key_file, file_name, 0, error) &&
1530       gtk_print_settings_load_key_file (settings, key_file, NULL, error))
1531     retval = TRUE;
1532
1533   g_key_file_free (key_file);
1534
1535   return retval;
1536 }
1537
1538 /**
1539  * gtk_print_settings_new_from_file:
1540  * @file_name: the filename to read the settings from
1541  * @error: return location for errors, or %NULL
1542  *
1543  * Reads the print settings from @file_name. Returns a new #GtkPrintSettings
1544  * object with the restored settings, or %NULL if an error occurred.
1545  * See gtk_print_settings_to_file().
1546  *
1547  * Return value: the restored #GtkPrintSettings
1548  *
1549  * Since: 2.12
1550  */
1551 GtkPrintSettings *
1552 gtk_print_settings_new_from_file (const gchar  *file_name,
1553                                   GError      **error)
1554 {
1555   GtkPrintSettings *settings = gtk_print_settings_new ();
1556
1557   if (!gtk_print_settings_load_file (settings, file_name, error))
1558     {
1559       g_object_unref (settings);
1560       settings = NULL;
1561     }
1562
1563   return settings;
1564 }
1565
1566 /**
1567  * gtk_print_settings_load_key_file:
1568  * @settings: a #GtkPrintSettings
1569  * @key_file: the #GKeyFile to retrieve the settings from
1570  * @group_name: the name of the group to use
1571  * @error: return location for errors, or %NULL
1572  *
1573  * Reads the print settings from the group @group_name in @key_file.
1574  *
1575  * Return value: %TRUE on success
1576  *
1577  * Since: 2.14
1578  */
1579 gboolean
1580 gtk_print_settings_load_key_file (GtkPrintSettings *settings,
1581                                   GKeyFile         *key_file,
1582                                   const gchar      *group_name,
1583                                   GError          **error)
1584 {
1585   gchar **keys;
1586   gsize n_keys, i;
1587   GError *err = NULL;
1588
1589   g_return_val_if_fail (GTK_IS_PRINT_SETTINGS (settings), FALSE);
1590   g_return_val_if_fail (key_file != NULL, FALSE);
1591
1592   if (!group_name)
1593     group_name = KEYFILE_GROUP_NAME;
1594
1595   keys = g_key_file_get_keys (key_file,
1596                               group_name,
1597                               &n_keys,
1598                               &err);
1599   if (err != NULL)
1600     {
1601       g_propagate_error (error, err);
1602       return FALSE;
1603     }
1604
1605   for (i = 0 ; i < n_keys; ++i)
1606     {
1607       gchar *value;
1608
1609       value = g_key_file_get_string (key_file,
1610                                      KEYFILE_GROUP_NAME,
1611                                      keys[i],
1612                                      NULL);
1613       if (!value)
1614         continue;
1615
1616       gtk_print_settings_set (settings, keys[i], value);
1617       g_free (value);
1618     }
1619
1620   g_strfreev (keys);
1621
1622   return TRUE;
1623 }
1624
1625 /**
1626  * gtk_print_settings_new_from_key_file:
1627  * @key_file: the #GKeyFile to retrieve the settings from
1628  * @group_name: the name of the group to use
1629  * @error: return location for errors, or %NULL
1630  *
1631  * Reads the print settings from the group @group_name in @key_file.
1632  * Returns a new #GtkPrintSettings object with the restored settings,
1633  * or %NULL if an error occurred.
1634  *
1635  * Return value: the restored #GtkPrintSettings
1636  *
1637  * Since: 2.12
1638  */
1639 GtkPrintSettings *
1640 gtk_print_settings_new_from_key_file (GKeyFile     *key_file,
1641                                       const gchar  *group_name,
1642                                       GError      **error)
1643 {
1644   GtkPrintSettings *settings = gtk_print_settings_new ();
1645
1646   if (!gtk_print_settings_load_key_file (settings, key_file,
1647                                          group_name, error))
1648     {
1649       g_object_unref (settings);
1650       settings = NULL;
1651     }
1652
1653   return settings;
1654 }
1655
1656 /**
1657  * gtk_print_settings_to_file:
1658  * @settings: a #GtkPrintSettings
1659  * @file_name: the file to save to
1660  * @error: return location for errors, or %NULL
1661  *
1662  * This function saves the print settings from @settings to @file_name.
1663  *
1664  * Return value: %TRUE on success
1665  *
1666  * Since: 2.12
1667  */
1668 gboolean
1669 gtk_print_settings_to_file (GtkPrintSettings  *settings,
1670                             const gchar       *file_name,
1671                             GError           **error)
1672 {
1673   GKeyFile *key_file;
1674   gboolean retval = FALSE;
1675   char *data = NULL;
1676   gsize len;
1677   GError *err = NULL;
1678
1679   g_return_val_if_fail (GTK_IS_PRINT_SETTINGS (settings), FALSE);
1680   g_return_val_if_fail (file_name != NULL, FALSE);
1681
1682   key_file = g_key_file_new ();
1683   gtk_print_settings_to_key_file (settings, key_file, NULL);
1684
1685   data = g_key_file_to_data (key_file, &len, &err);
1686   if (!data)
1687     goto out;
1688
1689   retval = g_file_set_contents (file_name, data, len, &err);
1690
1691 out:
1692   if (err != NULL)
1693     g_propagate_error (error, err);
1694
1695   g_key_file_free (key_file);
1696   g_free (data);
1697
1698   return retval;
1699 }
1700
1701 typedef struct {
1702   GKeyFile *key_file;
1703   const gchar *group_name;
1704 } SettingsData;
1705
1706 static void
1707 add_value_to_key_file (const gchar  *key,
1708                        const gchar  *value,
1709                        SettingsData *data)
1710 {
1711   g_key_file_set_string (data->key_file, data->group_name, key, value);
1712 }
1713
1714 /**
1715  * gtk_print_settings_to_key_file:
1716  * @settings: a #GtkPrintSettings
1717  * @key_file: the #GKeyFile to save the print settings to
1718  * @group_name: the group to add the settings to in @key_file, or
1719  *     %NULL to use the default "Print Settings"
1720  *
1721  * This function adds the print settings from @settings to @key_file.
1722  *
1723  * Since: 2.12
1724  */
1725 void
1726 gtk_print_settings_to_key_file (GtkPrintSettings  *settings,
1727                                 GKeyFile          *key_file,
1728                                 const gchar       *group_name)
1729 {
1730   SettingsData data;
1731
1732   g_return_if_fail (GTK_IS_PRINT_SETTINGS (settings));
1733   g_return_if_fail (key_file != NULL);
1734
1735   if (!group_name)
1736     group_name = KEYFILE_GROUP_NAME;
1737
1738   data.key_file = key_file;
1739   data.group_name = group_name;
1740
1741   gtk_print_settings_foreach (settings,
1742                               (GtkPrintSettingsFunc) add_value_to_key_file,
1743                               &data);
1744 }
1745
1746
1747 #define __GTK_PRINT_SETTINGS_C__
1748 #include "gtkaliasdef.c"