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

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