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