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

source code of gtk/gtk/gtkprintsettings.c