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

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