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