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