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