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

   1 /* GTK - The GIMP Toolkit
   2  * gtkprintsettings.c: Print Settings
   3  * Copyright (C) 2006, Red Hat, Inc.
   4  *
   5  * This library is free software; you can redistribute it and/or
   6  * modify it under the terms of the GNU Lesser General Public
   7  * License as published by the Free Software Foundation; either
   8  * version 2 of the License, or (at your option) any later version.
   9  *
  10  * This library is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13  * Lesser General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU Lesser General Public
  16  * License along with this library; if not, write to the
  17  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  18  * Boston, MA 02111-1307, USA.
  19  */
  20
  21 #include "config.h"
  22 #include <string.h>
  23 #include <stdlib.h>
  24 #include <glib/gprintf.h>
  25 #include "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 G_DEFINE_TYPE (GtkPrintSettings, gtk_print_settings, G_TYPE_OBJECT)
  49
  50 static void
  51 gtk_print_settings_finalize (GObject *object)
  52 {
  53   GtkPrintSettings *settings = GTK_PRINT_SETTINGS (object);
  54
  55   g_hash_table_destroy (settings->hash);
  56
  57   G_OBJECT_CLASS (gtk_print_settings_parent_class)->finalize (object);
  58 }
  59
  60 static void
  61 gtk_print_settings_init (GtkPrintSettings *settings)
  62 {
  63   settings->hash = g_hash_table_new_full (g_str_hash, g_str_equal,
  64                                           g_free, g_free);
  65 }
  66
  67 static void
  68 gtk_print_settings_class_init (GtkPrintSettingsClass *class)
  69 {
  70   GObjectClass *gobject_class = (GObjectClass *)class;
  71
  72   gobject_class->finalize = gtk_print_settings_finalize;
  73 }
  74
  75 /**
  76  * gtk_print_settings_new:
  77  *
  78  * Creates a new #GtkPrintSettings object.
  79  *
  80  * Return value: a new #GtkPrintSettings object
  81  *
  82  * Since: 2.10
  83  */
  84 GtkPrintSettings *
  85 gtk_print_settings_new (void)
  86 {
  87   return g_object_new (GTK_TYPE_PRINT_SETTINGS, NULL);
  88 }
  89
  90 static void
  91 copy_hash_entry  (gpointer  key,
  92                   gpointer  value,
  93                   gpointer  user_data)
  94 {
  95   GtkPrintSettings *settings = user_data;
  96
  97   g_hash_table_insert (settings->hash,
  98                        g_strdup (key),
  99                        g_strdup (value));
 100 }
 101
 102
 103
 104 /**
 105  * gtk_print_settings_copy:
 106  * @other: a #GtkPrintSettings
 107  *
 108  * Copies a #GtkPrintSettings object.
 109  *
 110  * Return value: a newly allocated copy of @other
 111  *
 112  * Since: 2.10
 113  */
 114 GtkPrintSettings *
 115 gtk_print_settings_copy (GtkPrintSettings *other)
 116 {
 117   GtkPrintSettings *settings;
 118
 119   if (other == NULL)
 120     return NULL;
 121
 122   g_return_val_if_fail (GTK_IS_PRINT_SETTINGS (other), NULL);
 123
 124   settings = gtk_print_settings_new ();
 125
 126   g_hash_table_foreach (other->hash,
 127                         copy_hash_entry,
 128                         settings);
 129
 130   return settings;
 131 }
 132
 133 /**
 134  * gtk_print_settings_get:
 135  * @settings: a #GtkPrintSettings
 136  * @key: a key
 137  *
 138  * Looks up the string value associated with @key.
 139  *
 140  * Return value: the string value for @key
 141  *
 142  * Since: 2.10
 143  */
 144 G_CONST_RETURN gchar *
 145 gtk_print_settings_get (GtkPrintSettings *settings,
 146                         const gchar      *key)
 147 {
 148   return g_hash_table_lookup (settings->hash, key);
 149 }
 150
 151 /**
 152  * gtk_print_settings_set:
 153  * @settings: a #GtkPrintSettings
 154  * @key: a key
 155  * @value: a string value, or %NULL
 156  *
 157  * Associates @value with @key.
 158  *
 159  * Since: 2.10
 160  */
 161 void
 162 gtk_print_settings_set (GtkPrintSettings *settings,
 163                         const gchar      *key,
 164                         const gchar      *value)
 165 {
 166   if (value == NULL)
 167     gtk_print_settings_unset (settings, key);
 168   else
 169     g_hash_table_insert (settings->hash,
 170                          g_strdup (key),
 171                          g_strdup (value));
 172 }
 173
 174 /**
 175  * gtk_print_settings_unset:
 176  * @settings: a #GtkPrintSettings
 177  * @key: a key
 178  *
 179  * Removes any value associated with @key.
 180  * This has the same effect as setting the value to %NULL.
 181  *
 182  * Since: 2.10
 183  */
 184 void
 185 gtk_print_settings_unset (GtkPrintSettings *settings,
 186                           const gchar      *key)
 187 {
 188   g_hash_table_remove (settings->hash, key);
 189 }
 190
 191 /**
 192  * gtk_print_settings_has_key:
 193  * @settings: a #GtkPrintSettings
 194  * @key: a key
 195  *
 196  * Returns %TRUE, if a value is associated with @key.
 197  *
 198  * Return value: %TRUE, if @key has a value
 199  *
 200  * Since: 2.10
 201  */
 202 gboolean
 203 gtk_print_settings_has_key (GtkPrintSettings *settings,
 204                             const gchar      *key)
 205 {
 206   return gtk_print_settings_get (settings, key) != NULL;
 207 }
 208
 209
 210 /**
 211  * gtk_print_settings_get_bool:
 212  * @settings: a #GtkPrintSettings
 213  * @key: a key
 214  *
 215  * Returns the boolean represented by the value
 216  * that is associated with @key.
 217  *
 218  * The string "true" represents %TRUE, any other
 219  * string %FALSE.
 220  *
 221  * Return value: %TRUE, if @key maps to a true value.
 222  *
 223  * Since: 2.10
 224  **/
 225 gboolean
 226 gtk_print_settings_get_bool (GtkPrintSettings *settings,
 227                              const gchar      *key)
 228 {
 229   const gchar *val;
 230
 231   val = gtk_print_settings_get (settings, key);
 232   if (val != NULL && strcmp (val, "true") == 0)
 233     return TRUE;
 234
 235   return FALSE;
 236 }
 237
 238 /**
 239  * gtk_print_settings_get_bool_with_default:
 240  * @settings: a #GtkPrintSettings
 241  * @key: a key
 242  * @default_val: the default value
 243  *
 244  * Returns the boolean represented by the value
 245  * that is associated with @key, or @default_val
 246  * if the value does not represent a boolean.
 247  *
 248  * The string "true" represents %TRUE, the string
 249  * "false" represents %FALSE.
 250  *
 251  * Return value: the boolean value associated with @key
 252  *
 253  * Since: 2.10
 254  */
 255 static gboolean
 256 gtk_print_settings_get_bool_with_default (GtkPrintSettings *settings,
 257                                           const gchar      *key,
 258                                           gboolean          default_val)
 259 {
 260   const gchar *val;
 261
 262   val = gtk_print_settings_get (settings, key);
 263   if (val != NULL && strcmp (val, "true") == 0)
 264     return TRUE;
 265
 266   if (val != NULL && strcmp (val, "false") == 0)
 267     return FALSE;
 268
 269   return default_val;
 270 }
 271
 272 /**
 273  * gtk_print_settings_set_bool:
 274  * @settings: a #GtkPrintSettings
 275  * @key: a key
 276  * @value: a boolean
 277  *
 278  * Sets @key to a boolean value.
 279  *
 280  * Since: 2.10
 281  */
 282 void
 283 gtk_print_settings_set_bool (GtkPrintSettings *settings,
 284                              const gchar      *key,
 285                              gboolean          value)
 286 {
 287   if (value)
 288     gtk_print_settings_set (settings, key, "true");
 289   else
 290     gtk_print_settings_set (settings, key, "false");
 291 }
 292
 293 /**
 294  * gtk_print_settings_get_double_with_default:
 295  * @settings: a #GtkPrintSettings
 296  * @key: a key
 297  * @def: the default value
 298  *
 299  * Returns the floating point number represented by
 300  * the value that is associated with @key, or @default_val
 301  * if the value does not represent a floating point number.
 302  *
 303  * Floating point numbers are parsed with g_ascii_strtod().
 304  *
 305  * Return value: the floating point number associated with @key
 306  *
 307  * Since: 2.10
 308  */
 309 gdouble
 310 gtk_print_settings_get_double_with_default (GtkPrintSettings *settings,
 311                                             const gchar      *key,
 312                                             gdouble           def)
 313 {
 314   const gchar *val;
 315
 316   val = gtk_print_settings_get (settings, key);
 317   if (val == NULL)
 318     return def;
 319
 320   return g_ascii_strtod (val, NULL);
 321 }
 322
 323 /**
 324  * gtk_print_settings_get_double:
 325  * @settings: a #GtkPrintSettings
 326  * @key: a key
 327  *
 328  * Returns the double value associated with @key, or 0.
 329  *
 330  * Return value: the double value of @key
 331  *
 332  * Since: 2.10
 333  */
 334 gdouble
 335 gtk_print_settings_get_double (GtkPrintSettings *settings,
 336                                const gchar      *key)
 337 {
 338   return gtk_print_settings_get_double_with_default (settings, key, 0.0);
 339 }
 340
 341 /**
 342  * gtk_print_settings_set_double:
 343  * @settings: a #GtkPrintSettings
 344  * @key: a key
 345  * @value: a double value
 346  *
 347  * Sets @key to a double value.
 348  *
 349  * Since: 2.10
 350  */
 351 void
 352 gtk_print_settings_set_double (GtkPrintSettings *settings,
 353                                const gchar      *key,
 354                                gdouble           value)
 355 {
 356   gchar buf[G_ASCII_DTOSTR_BUF_SIZE];
 357
 358   g_ascii_dtostr (buf, G_ASCII_DTOSTR_BUF_SIZE, value);
 359   gtk_print_settings_set (settings, key, buf);
 360 }
 361
 362 /**
 363  * gtk_print_settings_get_length:
 364  * @settings: a #GtkPrintSettings
 365  * @key: a key
 366  * @unit: the unit of the return value
 367  *
 368  * Returns the value associated with @key, interpreted
 369  * as a length. The returned value is converted to @units.
 370  *
 371  * Return value: the length value of @key, converted to @unit
 372  *
 373  * Since: 2.10
 374  */
 375 gdouble
 376 gtk_print_settings_get_length (GtkPrintSettings *settings,
 377                                const gchar      *key,
 378                                GtkUnit           unit)
 379 {
 380   gdouble length = gtk_print_settings_get_double (settings, key);
 381   return _gtk_print_convert_from_mm (length, unit);
 382 }
 383
 384 /**
 385  * gtk_print_settings_set_length:
 386  * @settings: a #GtkPrintSettings
 387  * @key: a key
 388  * @value: a length
 389  * @unit: the unit of @length
 390  *
 391  * Associates a length in units of @unit with @key.
 392  *
 393  * Since: 2.10
 394  */
 395 void
 396 gtk_print_settings_set_length (GtkPrintSettings *settings,
 397                                const gchar      *key,
 398                                gdouble           value,
 399                                GtkUnit           unit)
 400 {
 401   gtk_print_settings_set_double (settings, key,
 402                                  _gtk_print_convert_to_mm (value, unit));
 403 }
 404
 405 /**
 406  * gtk_print_settings_get_int_with_default:
 407  * @settings: a #GtkPrintSettings
 408  * @key: a key
 409  * @def: the default value
 410  *
 411  * Returns the value of @key, interpreted as
 412  * an integer, or the default value.
 413  *
 414  * Return value: the integer value of @key
 415  *
 416  * Since: 2.10
 417  */
 418 gint
 419 gtk_print_settings_get_int_with_default (GtkPrintSettings *settings,
 420                                          const gchar      *key,
 421                                          gint              def)
 422 {
 423   const gchar *val;
 424
 425   val = gtk_print_settings_get (settings, key);
 426   if (val == NULL)
 427     return def;
 428
 429   return atoi (val);
 430 }
 431
 432 /**
 433  * gtk_print_settings_get_int:
 434  * @settings: a #GtkPrintSettings
 435  * @key: a key
 436  *
 437  * Returns the integer value of @key, or 0.
 438  *
 439  * Return value: the integer value of @key
 440  *
 441  * Since: 2.10
 442  */
 443 gint
 444 gtk_print_settings_get_int (GtkPrintSettings *settings,
 445                             const gchar      *key)
 446 {
 447   return gtk_print_settings_get_int_with_default (settings, key, 0);
 448 }
 449
 450 /**
 451  * gtk_print_settings_set_int:
 452  * @settings: a #GtkPrintSettings
 453  * @key: a key
 454  * @value: an integer
 455  *
 456  * Sets @key to an integer value.
 457  *
 458  * Since: 2.10
 459  */
 460 void
 461 gtk_print_settings_set_int (GtkPrintSettings *settings,
 462                             const gchar      *key,
 463                             gint              value)
 464 {
 465   gchar buf[128];
 466   g_sprintf (buf, "%d", value);
 467   gtk_print_settings_set (settings, key, buf);
 468 }
 469
 470 /**
 471  * gtk_print_settings_foreach:
 472  * @settings: a #GtkPrintSettings
 473  * @func: the function to call
 474  * @user_data: user data for @func
 475  *
 476  * Calls @func for each key-value pair of @settings.
 477  *
 478  * Since: 2.10
 479  */
 480 void
 481 gtk_print_settings_foreach (GtkPrintSettings    *settings,
 482                             GtkPrintSettingsFunc func,
 483                             gpointer             user_data)
 484 {
 485   g_hash_table_foreach (settings->hash, (GHFunc)func, user_data);
 486 }
 487
 488 /**
 489  * gtk_print_settings_get_printer:
 490  * @settings: a #GtkPrintSettings
 491  *
 492  * Convenience function to obtain the value of
 493  * %GTK_PRINT_SETTINGS_PRINTER.
 494  *
 495  * Return value: the printer name
 496  *
 497  * Since: 2.10
 498  */
 499 G_CONST_RETURN gchar *
 500 gtk_print_settings_get_printer (GtkPrintSettings *settings)
 501 {
 502   return gtk_print_settings_get (settings, GTK_PRINT_SETTINGS_PRINTER);
 503 }
 504
 505
 506 /**
 507  * gtk_print_settings_set_printer:
 508  * @settings: a #GtkPrintSettings
 509  * @printer: the printer name
 510  *
 511  * Convenience function to set %GTK_PRINT_SETTINGS_PRINTER
 512  * to @printer.
 513  *
 514  * Since: 2.10
 515  */
 516 void
 517 gtk_print_settings_set_printer (GtkPrintSettings *settings,
 518                                 const gchar      *printer)
 519 {
 520   gtk_print_settings_set (settings, GTK_PRINT_SETTINGS_PRINTER, printer);
 521 }
 522
 523 /**
 524  * gtk_print_settings_get_orientation:
 525  * @settings: a #GtkPrintSettings
 526  *
 527  * Get the value of %GTK_PRINT_SETTINGS_ORIENTATION,
 528  * converted to a #GtkPageOrientation.
 529  *
 530  * Return value: the orientation
 531  *
 532  * Since: 2.10
 533  */
 534 GtkPageOrientation
 535 gtk_print_settings_get_orientation (GtkPrintSettings *settings)
 536 {
 537   const gchar *val;
 538
 539   val = gtk_print_settings_get (settings, GTK_PRINT_SETTINGS_ORIENTATION);
 540
 541   if (val == NULL || strcmp (val, "portrait") == 0)
 542     return GTK_PAGE_ORIENTATION_PORTRAIT;
 543
 544   if (strcmp (val, "landscape") == 0)
 545     return GTK_PAGE_ORIENTATION_LANDSCAPE;
 546
 547   if (strcmp (val, "reverse_portrait") == 0)
 548     return GTK_PAGE_ORIENTATION_REVERSE_PORTRAIT;
 549
 550   if (strcmp (val, "reverse_landscape") == 0)
 551     return GTK_PAGE_ORIENTATION_REVERSE_LANDSCAPE;
 552
 553   return GTK_PAGE_ORIENTATION_PORTRAIT;
 554 }
 555
 556 /**
 557  * gtk_print_settings_set_orientation:
 558  * @settings: a #GtkPrintSettings
 559  * @orientation: a page orientation
 560  *
 561  * Sets the value of %GTK_PRINT_SETTINGS_ORIENTATION.
 562  *
 563  * Since: 2.10
 564  */
 565 void
 566 gtk_print_settings_set_orientation (GtkPrintSettings   *settings,
 567                                     GtkPageOrientation  orientation)
 568 {
 569   const gchar *val;
 570
 571   switch (orientation)
 572     {
 573     case GTK_PAGE_ORIENTATION_LANDSCAPE:
 574       val = "landscape";
 575       break;
 576     default:
 577     case GTK_PAGE_ORIENTATION_PORTRAIT:
 578       val = "portrait";
 579       break;
 580     case GTK_PAGE_ORIENTATION_REVERSE_LANDSCAPE:
 581       val = "reverse_landscape";
 582       break;
 583     case GTK_PAGE_ORIENTATION_REVERSE_PORTRAIT:
 584       val = "reverse_portrait";
 585       break;
 586     }
 587   gtk_print_settings_set (settings, GTK_PRINT_SETTINGS_ORIENTATION, val);
 588 }
 589
 590 /**
 591  * gtk_print_settings_get_paper_size:
 592  * @settings: a #GtkPrintSettings
 593  *
 594  * Gets the value of %GTK_PRINT_SETTINGS_PAPER_FORMAT,
 595  * converted to a #GtkPaperSize.
 596  *
 597  * Return value: the paper size
 598  *
 599  * Since: 2.10
 600  */
 601 GtkPaperSize *
 602 gtk_print_settings_get_paper_size (GtkPrintSettings *settings)
 603 {
 604   const gchar *val;
 605   const gchar *name;
 606   gdouble w, h;
 607
 608   val = gtk_print_settings_get (settings, GTK_PRINT_SETTINGS_PAPER_FORMAT);
 609   if (val == NULL)
 610     return NULL;
 611
 612   if (g_str_has_prefix (val, "custom-"))
 613     {
 614       name = val + strlen ("custom-");
 615       w = gtk_print_settings_get_paper_width (settings, GTK_UNIT_MM);
 616       h = gtk_print_settings_get_paper_height (settings, GTK_UNIT_MM);
 617       return gtk_paper_size_new_custom (name, name, w, h, GTK_UNIT_MM);
 618     }
 619
 620   return gtk_paper_size_new (val);
 621 }
 622
 623 /**
 624  * gtk_print_settings_set_paper_size:
 625  * @settings: a #GtkPrintSettings
 626  * @paper_size: a paper size
 627  *
 628  * Sets the value of %GTK_PRINT_SETTINGS_PAPER_FORMAT,
 629  * %GTK_PRINT_SETTINGS_PAPER_WIDTH and
 630  * %GTK_PRINT_SETTINGS_PAPER_HEIGHT.
 631  *
 632  * Since: 2.10
 633  */
 634 void
 635 gtk_print_settings_set_paper_size (GtkPrintSettings *settings,
 636                                    GtkPaperSize     *paper_size)
 637 {
 638   gchar *custom_name;
 639
 640   if (paper_size == NULL)
 641     {
 642       gtk_print_settings_set (settings, GTK_PRINT_SETTINGS_PAPER_FORMAT, NULL);
 643       gtk_print_settings_set (settings, GTK_PRINT_SETTINGS_PAPER_WIDTH, NULL);
 644       gtk_print_settings_set (settings, GTK_PRINT_SETTINGS_PAPER_HEIGHT, NULL);
 645     }
 646   else if (gtk_paper_size_is_custom (paper_size))
 647     {
 648       custom_name = g_strdup_printf ("custom-%s",
 649                                      gtk_paper_size_get_name (paper_size));
 650       gtk_print_settings_set (settings, GTK_PRINT_SETTINGS_PAPER_FORMAT, custom_name);
 651       g_free (custom_name);
 652       gtk_print_settings_set_paper_width (settings,
 653                                           gtk_paper_size_get_width (paper_size,
 654                                                                     GTK_UNIT_MM),
 655                                           GTK_UNIT_MM);
 656       gtk_print_settings_set_paper_height (settings,
 657                                            gtk_paper_size_get_height (paper_size,
 658                                                                       GTK_UNIT_MM),
 659                                            GTK_UNIT_MM);
 660     }
 661   else
 662     gtk_print_settings_set (settings, GTK_PRINT_SETTINGS_PAPER_FORMAT,
 663                             gtk_paper_size_get_name (paper_size));
 664 }
 665
 666 /**
 667  * gtk_print_settings_get_paper_width:
 668  * @settings: a #GtkPrintSettings
 669  * @unit: the unit for the return value
 670  *
 671  * Gets the value of %GTK_PRINT_SETTINGS_PAPER_WIDTH,
 672  * converted to @unit.
 673  *
 674  * Return value: the paper width, in units of @unit
 675  *
 676  * Since: 2.10
 677  */
 678 gdouble
 679 gtk_print_settings_get_paper_width (GtkPrintSettings *settings,
 680                                     GtkUnit           unit)
 681 {
 682   return gtk_print_settings_get_length (settings, GTK_PRINT_SETTINGS_PAPER_WIDTH, unit);
 683 }
 684
 685 /**
 686  * gtk_print_settings_set_paper_width:
 687  * @settings: a #GtkPrintSettings
 688  * @width: the paper width
 689  * @unit: the units of @width
 690  *
 691  * Sets the value of %GTK_PRINT_SETTINGS_PAPER_WIDTH.
 692  *
 693  * Since: 2.10
 694  */
 695 void
 696 gtk_print_settings_set_paper_width (GtkPrintSettings *settings,
 697                                     gdouble           width,
 698                                     GtkUnit           unit)
 699 {
 700   gtk_print_settings_set_length (settings, GTK_PRINT_SETTINGS_PAPER_WIDTH, width, unit);
 701 }
 702
 703 /**
 704  * gtk_print_settings_get_paper_height:
 705  * @settings: a #GtkPrintSettings
 706  * @unit: the unit for the return value
 707  *
 708  * Gets the value of %GTK_PRINT_SETTINGS_PAPER_HEIGHT,
 709  * converted to @unit.
 710  *
 711  * Return value: the paper height, in units of @unit
 712  *
 713  * Since: 2.10
 714  */
 715 gdouble
 716 gtk_print_settings_get_paper_height (GtkPrintSettings *settings,
 717                                      GtkUnit           unit)
 718 {
 719   return gtk_print_settings_get_length (settings,
 720                                         GTK_PRINT_SETTINGS_PAPER_HEIGHT,
 721                                         unit);
 722 }
 723
 724 /**
 725  * gtk_print_settings_set_paper_height:
 726  * @settings: a #GtkPrintSettings
 727  * @height: the paper height
 728  * @unit: the units of @height
 729  *
 730  * Sets the value of %GTK_PRINT_SETTINGS_PAPER_HEIGHT.
 731  *
 732  * Since: 2.10
 733  */
 734 void
 735 gtk_print_settings_set_paper_height (GtkPrintSettings *settings,
 736                                      gdouble           height,
 737                                      GtkUnit           unit)
 738 {
 739   gtk_print_settings_set_length (settings,
 740                                  GTK_PRINT_SETTINGS_PAPER_HEIGHT,
 741                                  height, unit);
 742 }
 743
 744 /**
 745  * gtk_print_settings_get_use_color:
 746  * @settings: a #GtkPrintSettings
 747  *
 748  * Gets the value of %GTK_PRINT_SETTINGS_USE_COLOR.
 749  *
 750  * Return value: whether to use color
 751  *
 752  * Since: 2.10
 753  */
 754 gboolean
 755 gtk_print_settings_get_use_color (GtkPrintSettings *settings)
 756 {
 757   return gtk_print_settings_get_bool_with_default (settings,
 758                                                    GTK_PRINT_SETTINGS_USE_COLOR,
 759                                                    TRUE);
 760 }
 761
 762 /**
 763  * gtk_print_settings_set_use_color:
 764  * @settings: a #GtkPrintSettings
 765  * @use_color: whether to use color
 766  *
 767  * Sets the value of %GTK_PRINT_SETTINGS_USE_COLOR.
 768  *
 769  * Since: 2.10
 770  */
 771 void
 772 gtk_print_settings_set_use_color (GtkPrintSettings *settings,
 773                                   gboolean          use_color)
 774 {
 775   gtk_print_settings_set_bool (settings,
 776                                GTK_PRINT_SETTINGS_USE_COLOR,
 777                                use_color);
 778 }
 779
 780 /**
 781  * gtk_print_settings_get_collate:
 782  * @settings: a #GtkPrintSettings
 783  *
 784  * Gets the value of %GTK_PRINT_SETTINGS_COLLATE.
 785  *
 786  * Return value: whether to collate the printed pages
 787  *
 788  * Since: 2.10
 789  */
 790 gboolean
 791 gtk_print_settings_get_collate (GtkPrintSettings *settings)
 792 {
 793   return gtk_print_settings_get_bool (settings,
 794                                       GTK_PRINT_SETTINGS_COLLATE);
 795 }
 796
 797 /**
 798  * gtk_print_settings_set_collate:
 799  * @settings: a #GtkPrintSettings
 800  * @collate: whether to collate the output
 801  *
 802  * Sets the value of %GTK_PRINT_SETTINGS_COLLATE.
 803  *
 804  * Since: 2.10
 805  */
 806 void
 807 gtk_print_settings_set_collate (GtkPrintSettings *settings,
 808                                 gboolean          collate)
 809 {
 810   gtk_print_settings_set_bool (settings,
 811                                GTK_PRINT_SETTINGS_COLLATE,
 812                                collate);
 813 }
 814
 815 /**
 816  * gtk_print_settings_get_reverse:
 817  * @settings: a #GtkPrintSettings
 818  *
 819  * Gets the value of %GTK_PRINT_SETTINGS_REVERSE.
 820  *
 821  * Return value: whether to reverse the order of the printed pages
 822  *
 823  * Since: 2.10
 824  */
 825 gboolean
 826 gtk_print_settings_get_reverse (GtkPrintSettings *settings)
 827 {
 828   return gtk_print_settings_get_bool (settings,
 829                                       GTK_PRINT_SETTINGS_REVERSE);
 830 }
 831
 832 /**
 833  * gtk_print_settings_set_reverse:
 834  * @settings: a #GtkPrintSettings
 835  * @reverse: whether to reverse the output
 836  *
 837  * Sets the value of %GTK_PRINT_SETTINGS_REVERSE.
 838  *
 839  * Since: 2.10
 840  */
 841 void
 842 gtk_print_settings_set_reverse (GtkPrintSettings *settings,
 843                                   gboolean        reverse)
 844 {
 845   gtk_print_settings_set_bool (settings,
 846                                GTK_PRINT_SETTINGS_REVERSE,
 847                                reverse);
 848 }
 849
 850 /**
 851  * gtk_print_settings_get_duplex:
 852  * @settings: a #GtkPrintSettings
 853  *
 854  * Gets the value of %GTK_PRINT_SETTINGS_DUPLEX.
 855  *
 856  * Return value: whether to print the output in duplex.
 857  *
 858  * Since: 2.10
 859  */
 860 GtkPrintDuplex
 861 gtk_print_settings_get_duplex (GtkPrintSettings *settings)
 862 {
 863   const gchar *val;
 864
 865   val = gtk_print_settings_get (settings, GTK_PRINT_SETTINGS_DUPLEX);
 866
 867   if (val == NULL || (strcmp (val, "simplex") == 0))
 868     return GTK_PRINT_DUPLEX_SIMPLEX;
 869
 870   if (strcmp (val, "horizontal") == 0)
 871     return GTK_PRINT_DUPLEX_HORIZONTAL;
 872
 873   if (strcmp (val, "vertical") == 0)
 874     return GTK_PRINT_DUPLEX_HORIZONTAL;
 875
 876   return GTK_PRINT_DUPLEX_SIMPLEX;
 877 }
 878
 879 /**
 880  * gtk_print_settings_set_duplex:
 881  * @settings: a #GtkPrintSettings
 882  * @duplex: a #GtkPrintDuplex value
 883  *
 884  * Sets the value of %GTK_PRINT_SETTINGS_DUPLEX.
 885  *
 886  * Since: 2.10
 887  */
 888 void
 889 gtk_print_settings_set_duplex (GtkPrintSettings *settings,
 890                                GtkPrintDuplex    duplex)
 891 {
 892   const gchar *str;
 893
 894   switch (duplex)
 895     {
 896     default:
 897     case GTK_PRINT_DUPLEX_SIMPLEX:
 898       str = "simplex";
 899       break;
 900     case GTK_PRINT_DUPLEX_HORIZONTAL:
 901       str = "horizontal";
 902       break;
 903     case GTK_PRINT_DUPLEX_VERTICAL:
 904       str = "vertical";
 905       break;
 906     }
 907
 908   gtk_print_settings_set (settings, GTK_PRINT_SETTINGS_DUPLEX, str);
 909 }
 910
 911 /**
 912  * gtk_print_settings_get_quality:
 913  * @settings: a #GtkPrintSettings
 914  *
 915  * Gets the value of %GTK_PRINT_SETTINGS_QUALITY.
 916  *
 917  * Return value: the print quality
 918  *
 919  * Since: 2.10
 920  */
 921 GtkPrintQuality
 922 gtk_print_settings_get_quality (GtkPrintSettings *settings)
 923 {
 924   const gchar *val;
 925
 926   val = gtk_print_settings_get (settings, GTK_PRINT_SETTINGS_QUALITY);
 927
 928   if (val == NULL || (strcmp (val, "normal") == 0))
 929     return GTK_PRINT_QUALITY_NORMAL;
 930
 931   if (strcmp (val, "high") == 0)
 932     return GTK_PRINT_QUALITY_HIGH;
 933
 934   if (strcmp (val, "low") == 0)
 935     return GTK_PRINT_QUALITY_LOW;
 936
 937   if (strcmp (val, "draft") == 0)
 938     return GTK_PRINT_QUALITY_DRAFT;
 939
 940   return GTK_PRINT_QUALITY_NORMAL;
 941 }
 942
 943 /**
 944  * gtk_print_settings_set_quality:
 945  * @settings: a #GtkPrintSettings
 946  * @quality: a #GtkPrintQuality value
 947  *
 948  * Sets the value of %GTK_PRINT_SETTINGS_QUALITY.
 949  *
 950  * Since: 2.10
 951  */
 952 void
 953 gtk_print_settings_set_quality (GtkPrintSettings *settings,
 954                                 GtkPrintQuality   quality)
 955 {
 956   const gchar *str;
 957
 958   switch (quality)
 959     {
 960     default:
 961     case GTK_PRINT_QUALITY_NORMAL:
 962       str = "normal";
 963       break;
 964     case GTK_PRINT_QUALITY_HIGH:
 965       str = "high";
 966       break;
 967     case GTK_PRINT_QUALITY_LOW:
 968       str = "low";
 969       break;
 970     case GTK_PRINT_QUALITY_DRAFT:
 971       str = "draft";
 972       break;
 973     }
 974
 975   gtk_print_settings_set (settings, GTK_PRINT_SETTINGS_QUALITY, str);
 976 }
 977
 978 /**
 979  * gtk_print_settings_get_page_set:
 980  * @settings: a #GtkPrintSettings
 981  *
 982  * Gets the value of %GTK_PRINT_SETTINGS_PAGE_SET.
 983  *
 984  * Return value: the set of pages to print
 985  *
 986  * Since: 2.10
 987  */
 988 GtkPageSet
 989 gtk_print_settings_get_page_set (GtkPrintSettings *settings)
 990 {
 991   const gchar *val;
 992
 993   val = gtk_print_settings_get (settings, GTK_PRINT_SETTINGS_PAGE_SET);
 994
 995   if (val == NULL || (strcmp (val, "all") == 0))
 996     return GTK_PAGE_SET_ALL;
 997
 998   if (strcmp (val, "even") == 0)
 999     return GTK_PAGE_SET_EVEN;
1000
1001   if (strcmp (val, "odd") == 0)
1002     return GTK_PAGE_SET_ODD;
1003
1004   return GTK_PAGE_SET_ALL;
1005 }
1006
1007 /**
1008  * gtk_print_settings_set_page_set:
1009  * @settings: a #GtkPrintSettings
1010  * @page_set: a #GtkPageSet value
1011  *
1012  * Sets the value of %GTK_PRINT_SETTINGS_PAGE_SET.
1013  *
1014  * Since: 2.10
1015  */
1016 void
1017 gtk_print_settings_set_page_set (GtkPrintSettings *settings,
1018                                  GtkPageSet        page_set)
1019 {
1020   const gchar *str;
1021
1022   switch (page_set)
1023     {
1024     default:
1025     case GTK_PAGE_SET_ALL:
1026       str = "all";
1027       break;
1028     case GTK_PAGE_SET_EVEN:
1029       str = "even";
1030       break;
1031     case GTK_PAGE_SET_ODD:
1032       str = "odd";
1033       break;
1034     }
1035
1036   gtk_print_settings_set (settings, GTK_PRINT_SETTINGS_PAGE_SET, str);
1037 }
1038
1039 /**
1040  * gtk_print_settings_get_num_copies:
1041  * @settings: a #GtkPrintSettings
1042  *
1043  * Gets the value of %GTK_PRINT_SETTINGS_NUM_COPIES.
1044  *
1045  * Return value: the number of copies to print
1046  *
1047  * Since: 2.10
1048  */
1049 gint
1050 gtk_print_settings_get_num_copies (GtkPrintSettings *settings)
1051 {
1052   return gtk_print_settings_get_int_with_default (settings, GTK_PRINT_SETTINGS_NUM_COPIES, 1);
1053 }
1054
1055 /**
1056  * gtk_print_settings_set_num_copies:
1057  * @settings: a #GtkPrintSettings
1058  * @num_copies: the number of copies
1059  *
1060  * Sets the value of %GTK_PRINT_SETTINGS_NUM_COPIES.
1061  *
1062  * Since: 2.10
1063  */
1064 void
1065 gtk_print_settings_set_num_copies (GtkPrintSettings *settings,
1066                                    gint              num_copies)
1067 {
1068   gtk_print_settings_set_int (settings, GTK_PRINT_SETTINGS_NUM_COPIES,
1069                               num_copies);
1070 }
1071
1072 /**
1073  * gtk_print_settings_get_number_up:
1074  * @settings: a #GtkPrintSettings
1075  *
1076  * Gets the value of %GTK_PRINT_SETTINGS_NUMBER_UP.
1077  *
1078  * Return value: the number of pages per sheet
1079  *
1080  * Since: 2.10
1081  */
1082 gint
1083 gtk_print_settings_get_number_up (GtkPrintSettings *settings)
1084 {
1085   return gtk_print_settings_get_int (settings, GTK_PRINT_SETTINGS_NUMBER_UP);
1086 }
1087
1088 /**
1089  * gtk_print_settings_set_number_up:
1090  * @settings: a #GtkPrintSettings
1091  * @number_up: the number of pages per sheet
1092  *
1093  * Sets the value of %GTK_PRINT_SETTINGS_NUMBER_UP.
1094  *
1095  * Since: 2.10
1096  */
1097 void
1098 gtk_print_settings_set_number_up (GtkPrintSettings *settings,
1099                                   gint              number_up)
1100 {
1101   gtk_print_settings_set_int (settings, GTK_PRINT_SETTINGS_NUMBER_UP,
1102                                 number_up);
1103 }
1104
1105 /**
1106  * gtk_print_settings_get_resolution:
1107  * @settings: a #GtkPrintSettings
1108  *
1109  * Gets the value of %GTK_PRINT_SETTINGS_RESOLUTION.
1110  *
1111  * Return value: the resolution in dpi
1112  *
1113  * Since: 2.10
1114  */
1115 gint
1116 gtk_print_settings_get_resolution (GtkPrintSettings *settings)
1117 {
1118   return gtk_print_settings_get_int (settings, GTK_PRINT_SETTINGS_RESOLUTION);
1119 }
1120
1121 /**
1122  * gtk_print_settings_set_resolution:
1123  * @settings: a #GtkPrintSettings
1124  * @resolution: the resolution in dpi
1125  *
1126  * Sets the value of %GTK_PRINT_SETTINGS_RESOLUTION.
1127  *
1128  * Since: 2.10
1129  */
1130 void
1131 gtk_print_settings_set_resolution (GtkPrintSettings *settings,
1132                                    gint              resolution)
1133 {
1134   gtk_print_settings_set_int (settings, GTK_PRINT_SETTINGS_RESOLUTION,
1135                               resolution);
1136 }
1137
1138 /**
1139  * gtk_print_settings_get_scale:
1140  * @settings: a #GtkPrintSettings
1141  *
1142  * Gets the value of %GTK_PRINT_SETTINGS_SCALE.
1143  *
1144  * Return value: the scale in percent
1145  *
1146  * Since: 2.10
1147  */
1148 gdouble
1149 gtk_print_settings_get_scale (GtkPrintSettings *settings)
1150 {
1151   return gtk_print_settings_get_double_with_default (settings,
1152                                                      GTK_PRINT_SETTINGS_SCALE,
1153                                                      100.0);
1154 }
1155
1156 /**
1157  * gtk_print_settings_set_scale:
1158  * @settings: a #GtkPrintSettings
1159  * @scale: the scale in percent
1160  *
1161  * Sets the value of %GTK_PRINT_SETTINGS_SCALE.
1162  *
1163  * Since: 2.10
1164  */
1165 void
1166 gtk_print_settings_set_scale (GtkPrintSettings *settings,
1167                               gdouble           scale)
1168 {
1169   gtk_print_settings_set_double (settings, GTK_PRINT_SETTINGS_SCALE,
1170                                  scale);
1171 }
1172
1173 /**
1174  * gtk_print_settings_get_print_to_file:
1175  * @settings: a #GtkPrintSettings
1176  *
1177  * Gets the value of %GTK_PRINT_SETTINGS_PRINT_TO_FILE.
1178  *
1179  * Return value: whether to print to a file
1180  *
1181  * Since: 2.10
1182  */
1183 gboolean
1184 gtk_print_settings_get_print_to_file (GtkPrintSettings *settings)
1185 {
1186   return gtk_print_settings_get_bool (settings,
1187                                       GTK_PRINT_SETTINGS_PRINT_TO_FILE);
1188 }
1189
1190 /**
1191  * gtk_print_settings_set_print_to_file:
1192  * @settings: a #GtkPrintSettings
1193  * @print_to_file: whether to print to a file
1194  *
1195  * Sets the value of %GTK_PRINT_SETTINGS_PRINT_TO_FILE.
1196  *
1197  * Since: 2.10
1198  */
1199 void
1200 gtk_print_settings_set_print_to_file (GtkPrintSettings *settings,
1201                                       gboolean          print_to_file)
1202 {
1203   gtk_print_settings_set_bool (settings,
1204                                GTK_PRINT_SETTINGS_PRINT_TO_FILE,
1205                                print_to_file);
1206 }
1207
1208 /**
1209  * gtk_print_settings_get_print_pages:
1210  * @settings: a #GtkPrintSettings
1211  *
1212  * Gets the value of %GTK_PRINT_SETTINGS_PRINT_PAGES.
1213  *
1214  * Return value: which pages to print
1215  *
1216  * Since: 2.10
1217  */
1218 GtkPrintPages
1219 gtk_print_settings_get_print_pages (GtkPrintSettings *settings)
1220 {
1221   const gchar *val;
1222
1223   val = gtk_print_settings_get (settings, GTK_PRINT_SETTINGS_PRINT_PAGES);
1224
1225   if (val == NULL || (strcmp (val, "all") == 0))
1226     return GTK_PRINT_PAGES_ALL;
1227
1228   if (strcmp (val, "current") == 0)
1229     return GTK_PRINT_PAGES_CURRENT;
1230
1231   if (strcmp (val, "ranges") == 0)
1232     return GTK_PRINT_PAGES_RANGES;
1233
1234   return GTK_PRINT_PAGES_ALL;
1235 }
1236
1237 /**
1238  * gtk_print_settings_set_print_pages:
1239  * @settings: a #GtkPrintSettings
1240  * @pages: a #GtkPrintPages value
1241  *
1242  * Sets the value of %GTK_PRINT_SETTINGS_PRINT_PAGES.
1243  *
1244  * Since: 2.10
1245  */
1246 void
1247 gtk_print_settings_set_print_pages (GtkPrintSettings *settings,
1248                                     GtkPrintPages     pages)
1249 {
1250   const gchar *str;
1251
1252   switch (pages)
1253     {
1254     default:
1255     case GTK_PRINT_PAGES_ALL:
1256       str = "all";
1257       break;
1258     case GTK_PRINT_PAGES_CURRENT:
1259       str = "current";
1260       break;
1261     case GTK_PRINT_PAGES_RANGES:
1262       str = "ranges";
1263       break;
1264     }
1265
1266   gtk_print_settings_set (settings, GTK_PRINT_SETTINGS_PRINT_PAGES, str);
1267 }
1268
1269 /**
1270  * gtk_print_settings_get_page_ranges:
1271  * @settings: a #GtkPrintSettings
1272  * @num_ranges: return location for the length of the returned array
1273  *
1274  * Gets the value of %GTK_PRINT_SETTINGS_PAGE_RANGES.
1275  *
1276  * Return value: an array of #GtkPageRange<!-- -->s
1277  *
1278  * Since: 2.10
1279  */
1280 GtkPageRange *
1281 gtk_print_settings_get_page_ranges (GtkPrintSettings *settings,
1282                                     gint             *num_ranges)
1283 {
1284   const gchar *val;
1285   gchar **range_strs;
1286   GtkPageRange *ranges;
1287   gint i, n;
1288
1289   val = gtk_print_settings_get (settings, GTK_PRINT_SETTINGS_PAGE_RANGES);
1290
1291   if (val == NULL)
1292     {
1293       *num_ranges = 0;
1294       return NULL;
1295     }
1296
1297   range_strs = g_strsplit (val, ",", 0);
1298
1299   for (i = 0; range_strs[i] != NULL; i++)
1300     ;
1301
1302   n = i;
1303
1304   ranges = g_new0 (GtkPageRange, n);
1305
1306   for (i = 0; i < n; i++)
1307     {
1308       gint start, end;
1309       gchar *str;
1310
1311       start = (gint)strtol (range_strs[i], &str, 10);
1312       end = start;
1313
1314       if (*str == '-')
1315         {
1316           str++;
1317           end = (gint)strtol (str, NULL, 10);
1318           if (end < start)
1319             end = start;
1320         }
1321
1322       ranges[i].start = start;
1323       ranges[i].end = end;
1324     }
1325
1326   *num_ranges = n;
1327   return ranges;
1328 }
1329
1330 /**
1331  * gtk_print_settings_set_page_ranges:
1332  * @settings: a #GtkPrintSettings
1333  * @page_ranges: an array of #GtkPageRange<!-- -->s
1334  * @num_ranges: the length of @page_ranges
1335  *
1336  * Sets the value of %GTK_PRINT_SETTINGS_PAGE_RANGES.
1337  *
1338  * Since: 2.10
1339  */
1340 void
1341 gtk_print_settings_set_page_ranges  (GtkPrintSettings *settings,
1342                                      GtkPageRange     *page_ranges,
1343                                      gint              num_ranges)
1344 {
1345   GString *s;
1346   gint i;
1347
1348   s = g_string_new ("");
1349
1350   for (i = 0; i < num_ranges; i++)
1351     {
1352       if (page_ranges[i].start == page_ranges[i].end)
1353         g_string_append_printf (s, "%d", page_ranges[i].start);
1354       else
1355         g_string_append_printf (s, "%d-%d",
1356                                 page_ranges[i].start,
1357                                 page_ranges[i].end);
1358       if (i < num_ranges - 1)
1359         g_string_append (s, ",");
1360     }
1361
1362
1363   gtk_print_settings_set (settings, GTK_PRINT_SETTINGS_PAGE_RANGES,
1364                           s->str);
1365
1366   g_string_free (s, TRUE);
1367 }
1368
1369 /**
1370  * gtk_print_settings_get_default_source:
1371  * @settings: a #GtkPrintSettings
1372  *
1373  * Gets the value of %GTK_PRINT_SETTINGS_DEFAULT_SOURCE.
1374  *
1375  * Return value: the default source
1376  *
1377  * Since: 2.10
1378  */
1379 G_CONST_RETURN gchar *
1380 gtk_print_settings_get_default_source (GtkPrintSettings *settings)
1381 {
1382   return gtk_print_settings_get (settings, GTK_PRINT_SETTINGS_DEFAULT_SOURCE);
1383 }
1384
1385 /**
1386  * gtk_print_settings_set_default_source:
1387  * @settings: a #GtkPrintSettings
1388  * @default_source: the default source
1389  *
1390  * Sets the value of %GTK_PRINT_SETTINGS_DEFAULT_SOURCE.
1391  *
1392  * Since: 2.10
1393  */
1394 void
1395 gtk_print_settings_set_default_source (GtkPrintSettings *settings,
1396                                        const gchar      *default_source)
1397 {
1398   gtk_print_settings_set (settings, GTK_PRINT_SETTINGS_DEFAULT_SOURCE, default_source);
1399 }
1400
1401 /**
1402  * gtk_print_settings_get_media_type:
1403  * @settings: a #GtkPrintSettings
1404  *
1405  * Gets the value of %GTK_PRINT_SETTINGS_MEDIA_TYPE.
1406  *
1407  * The set of media types is defined in PWG 5101.1-2002 PWG.
1408  * <!-- FIXME link here -->
1409  *
1410  * Return value: the media type
1411  *
1412  * Since: 2.10
1413  */
1414 G_CONST_RETURN gchar *
1415 gtk_print_settings_get_media_type (GtkPrintSettings *settings)
1416 {
1417   return gtk_print_settings_get (settings, GTK_PRINT_SETTINGS_MEDIA_TYPE);
1418 }
1419
1420 /**
1421  * gtk_print_settings_set_media_type:
1422  * @settings: a #GtkPrintSettings
1423  * @media_type: the media type
1424  *
1425  * Sets the value of %GTK_PRINT_SETTINGS_MEDIA_TYPE.
1426  *
1427  * The set of media types is defined in PWG 5101.1-2002 PWG.
1428  * <!-- FIXME link here -->
1429  *
1430  * Since: 2.10
1431  */
1432 void
1433 gtk_print_settings_set_media_type (GtkPrintSettings *settings,
1434                                    const gchar      *media_type)
1435 {
1436   gtk_print_settings_set (settings, GTK_PRINT_SETTINGS_MEDIA_TYPE, media_type);
1437 }
1438
1439 /**
1440  * gtk_print_settings_get_dither:
1441  * @settings: a #GtkPrintSettings
1442  *
1443  * Gets the value of %GTK_PRINT_SETTINGS_DITHER.
1444  *
1445  * Return value: the dithering that is used
1446  *
1447  * Since: 2.10
1448  */
1449 G_CONST_RETURN gchar *
1450 gtk_print_settings_get_dither (GtkPrintSettings *settings)
1451 {
1452   return gtk_print_settings_get (settings, GTK_PRINT_SETTINGS_DITHER);
1453 }
1454
1455 /**
1456  * gtk_print_settings_set_dither:
1457  * @settings: a #GtkPrintSettings
1458  * @dither: the dithering that is used
1459  *
1460  * Sets the value of %GTK_PRINT_SETTINGS_DITHER.
1461  *
1462  * Since: 2.10
1463  */
1464 void
1465 gtk_print_settings_set_dither (GtkPrintSettings *settings,
1466                                const gchar      *dither)
1467 {
1468   gtk_print_settings_set (settings, GTK_PRINT_SETTINGS_DITHER, dither);
1469 }
1470
1471 /**
1472  * gtk_print_settings_get_finishings:
1473  * @settings: a #GtkPrintSettings
1474  *
1475  * Gets the value of %GTK_PRINT_SETTINGS_FINISHINGS.
1476  *
1477  * Return value: the finishings
1478  *
1479  * Since: 2.10
1480  */
1481 const gchar *
1482 gtk_print_settings_get_finishings (GtkPrintSettings *settings)
1483 {
1484   return gtk_print_settings_get (settings, GTK_PRINT_SETTINGS_FINISHINGS);
1485 }
1486
1487 /**
1488  * gtk_print_settings_set_finishings:
1489  * @settings: a #GtkPrintSettings
1490  * @finishings: the finishings
1491  *
1492  * Sets the value of %GTK_PRINT_SETTINGS_FINISHINGS.
1493  *
1494  * Since: 2.10
1495  */
1496 void
1497 gtk_print_settings_set_finishings (GtkPrintSettings *settings,
1498                                    const gchar      *finishings)
1499 {
1500   gtk_print_settings_set (settings, GTK_PRINT_SETTINGS_FINISHINGS, finishings);
1501 }
1502
1503 /**
1504  * gtk_print_settings_get_output_bin:
1505  * @settings: a #GtkPrintSettings
1506  *
1507  * Gets the value of %GTK_PRINT_SETTINGS_OUTPUT_BIN.
1508  *
1509  * Return value: the output bin
1510  *
1511  * Since: 2.10
1512  */
1513 G_CONST_RETURN gchar *
1514 gtk_print_settings_get_output_bin (GtkPrintSettings *settings)
1515 {
1516   return gtk_print_settings_get (settings, GTK_PRINT_SETTINGS_OUTPUT_BIN);
1517 }
1518
1519 /**
1520  * gtk_print_settings_set_output_bin:
1521  * @settings: a #GtkPrintSettings
1522  * @output_bin: the output bin
1523  *
1524  * Sets the value of %GTK_PRINT_SETTINGS_OUTPUT_BIN.
1525  *
1526  * Since: 2.10
1527  */
1528 void
1529 gtk_print_settings_set_output_bin (GtkPrintSettings *settings,
1530                                    const gchar      *output_bin)
1531 {
1532   gtk_print_settings_set (settings, GTK_PRINT_SETTINGS_OUTPUT_BIN, output_bin);
1533 }
1534
1535
1536 #define __GTK_PRINT_SETTINGS_C__
1537 #include "gtkaliasdef.c"