1/* GtkPrintJob
2 * Copyright (C) 2006 John (J5) Palmieri <johnp@redhat.com>
3 *
4 * This library is free software; you can redistribute it and/or
5 * modify it under the terms of the GNU Lesser General Public
6 * License as published by the Free Software Foundation; either
7 * version 2 of the License, or (at your option) any later version.
8 *
9 * This library is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12 * Lesser General Public License for more details.
13 *
14 * You should have received a copy of the GNU Lesser General Public
15 * License along with this library. If not, see <http://www.gnu.org/licenses/>.
16 */
17
18/**
19 * GtkPrintJob:
20 *
21 * A `GtkPrintJob` object represents a job that is sent to a printer.
22 *
23 * You only need to deal directly with print jobs if you use the
24 * non-portable [class@Gtk.PrintUnixDialog] API.
25 *
26 * Use [method@Gtk.PrintJob.get_surface] to obtain the cairo surface
27 * onto which the pages must be drawn. Use [method@Gtk.PrintJob.send]
28 * to send the finished job to the printer. If you don’t use cairo
29 * `GtkPrintJob` also supports printing of manually generated PostScript,
30 * via [method@Gtk.PrintJob.set_source_file].
31 */
32#include "config.h"
33#include <stdlib.h>
34#include <string.h>
35#include <stdio.h>
36#include <fcntl.h>
37#include <errno.h>
38#ifdef HAVE_UNISTD_H
39#include <unistd.h>
40#endif
41#include <sys/types.h>
42#include <sys/stat.h>
43
44#include <glib/gstdio.h>
45#include "gtkintl.h"
46#include "gtkprivate.h"
47
48#include "gtkprintjob.h"
49#include "gtkprinter.h"
50#include "gtkprinterprivate.h"
51#include "gtkprintbackendprivate.h"
52
53#ifndef O_BINARY
54#define O_BINARY 0
55#endif
56
57typedef struct _GtkPrintJobClass GtkPrintJobClass;
58
59struct _GtkPrintJob
60{
61 GObject parent_instance;
62
63 char *title;
64
65 GIOChannel *spool_io;
66 cairo_surface_t *surface;
67
68 GtkPrintStatus status;
69 GtkPrintBackend *backend;
70 GtkPrinter *printer;
71 GtkPrintSettings *settings;
72 GtkPageSetup *page_setup;
73
74 GtkPrintPages print_pages;
75 GtkPageRange *page_ranges;
76 int num_page_ranges;
77 GtkPageSet page_set;
78 int num_copies;
79 double scale;
80 guint number_up;
81 GtkNumberUpLayout number_up_layout;
82
83 guint printer_set : 1;
84 guint page_setup_set : 1;
85 guint settings_set : 1;
86 guint track_print_status : 1;
87 guint rotate_to_orientation : 1;
88 guint collate : 1;
89 guint reverse : 1;
90};
91
92struct _GtkPrintJobClass
93{
94 GObjectClass parent_class;
95
96 void (*status_changed) (GtkPrintJob *job);
97};
98
99static void gtk_print_job_finalize (GObject *object);
100static void gtk_print_job_set_property (GObject *object,
101 guint prop_id,
102 const GValue *value,
103 GParamSpec *pspec);
104static void gtk_print_job_get_property (GObject *object,
105 guint prop_id,
106 GValue *value,
107 GParamSpec *pspec);
108static void gtk_print_job_constructed (GObject *object);
109
110enum {
111 STATUS_CHANGED,
112 LAST_SIGNAL
113};
114
115enum {
116 PROP_0,
117 PROP_TITLE,
118 PROP_PRINTER,
119 PROP_PAGE_SETUP,
120 PROP_SETTINGS,
121 PROP_TRACK_PRINT_STATUS
122};
123
124static guint signals[LAST_SIGNAL] = { 0 };
125
126G_DEFINE_TYPE (GtkPrintJob, gtk_print_job, G_TYPE_OBJECT)
127
128static void
129gtk_print_job_class_init (GtkPrintJobClass *class)
130{
131 GObjectClass *object_class;
132 object_class = (GObjectClass *) class;
133
134 object_class->finalize = gtk_print_job_finalize;
135 object_class->constructed = gtk_print_job_constructed;
136 object_class->set_property = gtk_print_job_set_property;
137 object_class->get_property = gtk_print_job_get_property;
138
139 /**
140 * GtkPrintJob:title: (attributes org.gtk.Property.get=gtk_print_job_get_title)
141 *
142 * The title of the print job.
143 */
144 g_object_class_install_property (oclass: object_class,
145 property_id: PROP_TITLE,
146 pspec: g_param_spec_string (name: "title",
147 P_("Title"),
148 P_("Title of the print job"),
149 NULL,
150 GTK_PARAM_READWRITE |
151 G_PARAM_CONSTRUCT_ONLY));
152
153 /**
154 * GtkPrintJob:printer: (attributes org.gtk.Property.get=gtk_print_job_get_printer)
155 *
156 * The printer to send the job to.
157 */
158 g_object_class_install_property (oclass: object_class,
159 property_id: PROP_PRINTER,
160 pspec: g_param_spec_object (name: "printer",
161 P_("Printer"),
162 P_("Printer to print the job to"),
163 GTK_TYPE_PRINTER,
164 GTK_PARAM_READWRITE |
165 G_PARAM_CONSTRUCT_ONLY));
166
167 /**
168 * GtkPrintJob:settings: (attributes org.gtk.Property.get=gtk_print_job_get_settings)
169 *
170 * Printer settings.
171 */
172 g_object_class_install_property (oclass: object_class,
173 property_id: PROP_SETTINGS,
174 pspec: g_param_spec_object (name: "settings",
175 P_("Settings"),
176 P_("Printer settings"),
177 GTK_TYPE_PRINT_SETTINGS,
178 GTK_PARAM_READWRITE |
179 G_PARAM_CONSTRUCT_ONLY));
180
181 /**
182 * GtkPrintJob:page-setup:
183 *
184 * Page setup.
185 */
186 g_object_class_install_property (oclass: object_class,
187 property_id: PROP_PAGE_SETUP,
188 pspec: g_param_spec_object (name: "page-setup",
189 P_("Page Setup"),
190 P_("Page Setup"),
191 GTK_TYPE_PAGE_SETUP,
192 GTK_PARAM_READWRITE |
193 G_PARAM_CONSTRUCT_ONLY));
194
195 /**
196 * GtkPrintJob:track-print-status: (attributes org.gtk.Property.get=gtk_print_job_get_track_print_status org.gtk.Property.set=gtk_print_job_set_track_print_status)
197 *
198 * %TRUE if the print job will continue to emit status-changed
199 * signals after the print data has been setn to the printer.
200 */
201 g_object_class_install_property (oclass: object_class,
202 property_id: PROP_TRACK_PRINT_STATUS,
203 pspec: g_param_spec_boolean (name: "track-print-status",
204 P_("Track Print Status"),
205 P_("TRUE if the print job will continue to emit "
206 "status-changed signals after the print data "
207 "has been sent to the printer or print server."),
208 FALSE,
209 GTK_PARAM_READWRITE));
210
211 /**
212 * GtkPrintJob::status-changed:
213 * @job: the `GtkPrintJob` object on which the signal was emitted
214 *
215 * Emitted when the status of a job changes.
216 *
217 * The signal handler can use [method@Gtk.PrintJob.get_status]
218 * to obtain the new status.
219 */
220 signals[STATUS_CHANGED] =
221 g_signal_new (I_("status-changed"),
222 G_TYPE_FROM_CLASS (class),
223 signal_flags: G_SIGNAL_RUN_LAST,
224 G_STRUCT_OFFSET (GtkPrintJobClass, status_changed),
225 NULL, NULL,
226 NULL,
227 G_TYPE_NONE, n_params: 0);
228}
229
230static void
231gtk_print_job_init (GtkPrintJob *job)
232{
233 job->spool_io = NULL;
234
235 job->title = g_strdup (str: "");
236 job->surface = NULL;
237 job->backend = NULL;
238 job->printer = NULL;
239
240 job->printer_set = FALSE;
241 job->settings_set = FALSE;
242 job->page_setup_set = FALSE;
243 job->status = GTK_PRINT_STATUS_INITIAL;
244 job->track_print_status = FALSE;
245
246 job->print_pages = GTK_PRINT_PAGES_ALL;
247 job->page_ranges = NULL;
248 job->num_page_ranges = 0;
249 job->collate = FALSE;
250 job->reverse = FALSE;
251 job->num_copies = 1;
252 job->scale = 1.0;
253 job->page_set = GTK_PAGE_SET_ALL;
254 job->rotate_to_orientation = FALSE;
255 job->number_up = 1;
256 job->number_up_layout = GTK_NUMBER_UP_LAYOUT_LEFT_TO_RIGHT_TOP_TO_BOTTOM;
257}
258
259
260static void
261gtk_print_job_constructed (GObject *object)
262{
263 GtkPrintJob *job = GTK_PRINT_JOB (object);
264
265 G_OBJECT_CLASS (gtk_print_job_parent_class)->constructed (object);
266
267 g_assert (job->printer_set &&
268 job->settings_set &&
269 job->page_setup_set);
270
271 _gtk_printer_prepare_for_print (printer: job->printer,
272 print_job: job,
273 settings: job->settings,
274 page_setup: job->page_setup);
275}
276
277
278static void
279gtk_print_job_finalize (GObject *object)
280{
281 GtkPrintJob *job = GTK_PRINT_JOB (object);
282
283 if (job->surface)
284 cairo_surface_destroy (surface: job->surface);
285
286 if (job->backend)
287 g_object_unref (object: job->backend);
288
289 if (job->spool_io != NULL)
290 {
291 g_io_channel_unref (channel: job->spool_io);
292 job->spool_io = NULL;
293 }
294
295 if (job->printer)
296 g_object_unref (object: job->printer);
297
298 if (job->settings)
299 g_object_unref (object: job->settings);
300
301 if (job->page_setup)
302 g_object_unref (object: job->page_setup);
303
304 g_free (mem: job->page_ranges);
305 job->page_ranges = NULL;
306
307 g_free (mem: job->title);
308 job->title = NULL;
309
310 G_OBJECT_CLASS (gtk_print_job_parent_class)->finalize (object);
311}
312
313/**
314 * gtk_print_job_new:
315 * @title: the job title
316 * @printer: a `GtkPrinter`
317 * @settings: a `GtkPrintSettings`
318 * @page_setup: a `GtkPageSetup`
319 *
320 * Creates a new `GtkPrintJob`.
321 *
322 * Returns: a new `GtkPrintJob`
323 */
324GtkPrintJob *
325gtk_print_job_new (const char *title,
326 GtkPrinter *printer,
327 GtkPrintSettings *settings,
328 GtkPageSetup *page_setup)
329{
330 GObject *result;
331 result = g_object_new (GTK_TYPE_PRINT_JOB,
332 first_property_name: "title", title,
333 "printer", printer,
334 "settings", settings,
335 "page-setup", page_setup,
336 NULL);
337 return (GtkPrintJob *) result;
338}
339
340/**
341 * gtk_print_job_get_settings: (attributes org.gtk.Method.get_property=settings)
342 * @job: a `GtkPrintJob`
343 *
344 * Gets the `GtkPrintSettings` of the print job.
345 *
346 * Returns: (transfer none): the settings of @job
347 */
348GtkPrintSettings *
349gtk_print_job_get_settings (GtkPrintJob *job)
350{
351 g_return_val_if_fail (GTK_IS_PRINT_JOB (job), NULL);
352
353 return job->settings;
354}
355
356/**
357 * gtk_print_job_get_printer: (attributes org.gtk.Method.get_property=printer)
358 * @job: a `GtkPrintJob`
359 *
360 * Gets the `GtkPrinter` of the print job.
361 *
362 * Returns: (transfer none): the printer of @job
363 */
364GtkPrinter *
365gtk_print_job_get_printer (GtkPrintJob *job)
366{
367 g_return_val_if_fail (GTK_IS_PRINT_JOB (job), NULL);
368
369 return job->printer;
370}
371
372/**
373 * gtk_print_job_get_title: (attributes org.gtk.Method.get_property=title)
374 * @job: a `GtkPrintJob`
375 *
376 * Gets the job title.
377 *
378 * Returns: the title of @job
379 */
380const char *
381gtk_print_job_get_title (GtkPrintJob *job)
382{
383 g_return_val_if_fail (GTK_IS_PRINT_JOB (job), NULL);
384
385 return job->title;
386}
387
388/**
389 * gtk_print_job_get_status:
390 * @job: a `GtkPrintJob`
391 *
392 * Gets the status of the print job.
393 *
394 * Returns: the status of @job
395 */
396GtkPrintStatus
397gtk_print_job_get_status (GtkPrintJob *job)
398{
399 g_return_val_if_fail (GTK_IS_PRINT_JOB (job), GTK_PRINT_STATUS_FINISHED);
400
401 return job->status;
402}
403
404void
405gtk_print_job_set_status (GtkPrintJob *job,
406 GtkPrintStatus status)
407{
408 g_return_if_fail (GTK_IS_PRINT_JOB (job));
409
410 if (job->status == status)
411 return;
412
413 job->status = status;
414 g_signal_emit (instance: job, signal_id: signals[STATUS_CHANGED], detail: 0);
415}
416
417/**
418 * gtk_print_job_set_source_file:
419 * @job: a `GtkPrintJob`
420 * @filename: (type filename): the file to be printed
421 * @error: return location for errors
422 *
423 * Make the `GtkPrintJob` send an existing document to the
424 * printing system.
425 *
426 * The file can be in any format understood by the platforms
427 * printing system (typically PostScript, but on many platforms
428 * PDF may work too). See [method@Gtk.Printer.accepts_pdf] and
429 * [method@Gtk.Printer.accepts_ps].
430 *
431 * Returns: %FALSE if an error occurred
432 */
433gboolean
434gtk_print_job_set_source_file (GtkPrintJob *job,
435 const char *filename,
436 GError **error)
437{
438 GError *tmp_error;
439
440 tmp_error = NULL;
441
442 g_return_val_if_fail (GTK_IS_PRINT_JOB (job), FALSE);
443
444 if (job->spool_io != NULL)
445 g_io_channel_unref (channel: job->spool_io);
446
447 job->spool_io = g_io_channel_new_file (filename, mode: "r", error: &tmp_error);
448
449 if (tmp_error == NULL)
450 g_io_channel_set_encoding (channel: job->spool_io, NULL, error: &tmp_error);
451
452 if (tmp_error != NULL)
453 {
454 g_propagate_error (dest: error, src: tmp_error);
455 return FALSE;
456 }
457
458 return TRUE;
459}
460
461/**
462 * gtk_print_job_set_source_fd:
463 * @job: a `GtkPrintJob`
464 * @fd: a file descriptor
465 * @error: return location for errors
466 *
467 * Make the `GtkPrintJob` send an existing document to the
468 * printing system.
469 *
470 * The file can be in any format understood by the platforms
471 * printing system (typically PostScript, but on many platforms
472 * PDF may work too). See [method@Gtk.Printer.accepts_pdf] and
473 * [method@Gtk.Printer.accepts_ps].
474 *
475 * This is similar to [method@Gtk.PrintJob.set_source_file],
476 * but takes expects an open file descriptor for the file,
477 * instead of a filename.
478 *
479 * Returns: %FALSE if an error occurred
480 */
481gboolean
482gtk_print_job_set_source_fd (GtkPrintJob *job,
483 int fd,
484 GError **error)
485{
486 g_return_val_if_fail (GTK_IS_PRINT_JOB (job), FALSE);
487 g_return_val_if_fail (fd >= 0, FALSE);
488
489 if (job->spool_io != NULL)
490 g_io_channel_unref (channel: job->spool_io);
491
492 job->spool_io = g_io_channel_unix_new (fd);
493 if (g_io_channel_set_encoding (channel: job->spool_io, NULL, error) != G_IO_STATUS_NORMAL)
494 return FALSE;
495
496 return TRUE;
497}
498
499/**
500 * gtk_print_job_get_surface:
501 * @job: a `GtkPrintJob`
502 * @error: (nullable): return location for errors
503 *
504 * Gets a cairo surface onto which the pages of
505 * the print job should be rendered.
506 *
507 * Returns: (transfer none): the cairo surface of @job
508 */
509cairo_surface_t *
510gtk_print_job_get_surface (GtkPrintJob *job,
511 GError **error)
512{
513 char *filename = NULL;
514 double width, height;
515 GtkPaperSize *paper_size;
516 int fd;
517 GError *tmp_error;
518
519 tmp_error = NULL;
520
521 g_return_val_if_fail (GTK_IS_PRINT_JOB (job), NULL);
522
523 if (job->surface)
524 return job->surface;
525
526 g_return_val_if_fail (job->spool_io == NULL, NULL);
527
528 fd = g_file_open_tmp (tmpl: "gtkprint_XXXXXX",
529 name_used: &filename,
530 error: &tmp_error);
531 if (fd == -1)
532 {
533 g_free (mem: filename);
534 g_propagate_error (dest: error, src: tmp_error);
535 return NULL;
536 }
537
538 fchmod (fd: fd, S_IRUSR | S_IWUSR);
539
540#ifdef G_ENABLE_DEBUG
541 /* If we are debugging printing don't delete the tmp files */
542 if (GTK_DEBUG_CHECK (PRINTING)) ;
543 else
544#endif /* G_ENABLE_DEBUG */
545 g_unlink (filename);
546 g_free (mem: filename);
547
548 paper_size = gtk_page_setup_get_paper_size (setup: job->page_setup);
549 width = gtk_paper_size_get_width (size: paper_size, unit: GTK_UNIT_POINTS);
550 height = gtk_paper_size_get_height (size: paper_size, unit: GTK_UNIT_POINTS);
551
552 job->spool_io = g_io_channel_unix_new (fd);
553 g_io_channel_set_close_on_unref (channel: job->spool_io, TRUE);
554 g_io_channel_set_encoding (channel: job->spool_io, NULL, error: &tmp_error);
555
556 if (tmp_error != NULL)
557 {
558 g_io_channel_unref (channel: job->spool_io);
559 job->spool_io = NULL;
560 g_propagate_error (dest: error, src: tmp_error);
561 return NULL;
562 }
563
564 job->surface = _gtk_printer_create_cairo_surface (printer: job->printer,
565 settings: job->settings,
566 width, height,
567 cache_io: job->spool_io);
568
569 return job->surface;
570}
571
572/**
573 * gtk_print_job_set_track_print_status: (attributes org.gtk.Method.set_property=track-print-status)
574 * @job: a `GtkPrintJob`
575 * @track_status: %TRUE to track status after printing
576 *
577 * If track_status is %TRUE, the print job will try to continue report
578 * on the status of the print job in the printer queues and printer.
579 *
580 * This can allow your application to show things like “out of paper”
581 * issues, and when the print job actually reaches the printer.
582 *
583 * This function is often implemented using some form of polling,
584 * so it should not be enabled unless needed.
585 */
586void
587gtk_print_job_set_track_print_status (GtkPrintJob *job,
588 gboolean track_status)
589{
590 g_return_if_fail (GTK_IS_PRINT_JOB (job));
591
592 track_status = track_status != FALSE;
593
594 if (job->track_print_status != track_status)
595 {
596 job->track_print_status = track_status;
597
598 g_object_notify (G_OBJECT (job), property_name: "track-print-status");
599 }
600}
601
602/**
603 * gtk_print_job_get_track_print_status: (attributes org.gtk.Method.get_property=track-print-status)
604 * @job: a `GtkPrintJob`
605 *
606 * Returns whether jobs will be tracked after printing.
607 *
608 * For details, see [method@Gtk.PrintJob.set_track_print_status].
609 *
610 * Returns: %TRUE if print job status will be reported after printing
611 */
612gboolean
613gtk_print_job_get_track_print_status (GtkPrintJob *job)
614{
615 g_return_val_if_fail (GTK_IS_PRINT_JOB (job), FALSE);
616
617 return job->track_print_status;
618}
619
620static void
621gtk_print_job_set_property (GObject *object,
622 guint prop_id,
623 const GValue *value,
624 GParamSpec *pspec)
625
626{
627 GtkPrintJob *job = GTK_PRINT_JOB (object);
628 GtkPrintSettings *settings;
629
630 switch (prop_id)
631 {
632 case PROP_TITLE:
633 g_free (mem: job->title);
634 job->title = g_value_dup_string (value);
635 break;
636
637 case PROP_PRINTER:
638 job->printer = GTK_PRINTER (g_value_dup_object (value));
639 job->printer_set = TRUE;
640 job->backend = g_object_ref (gtk_printer_get_backend (job->printer));
641 break;
642
643 case PROP_PAGE_SETUP:
644 job->page_setup = GTK_PAGE_SETUP (g_value_dup_object (value));
645 job->page_setup_set = TRUE;
646 break;
647
648 case PROP_SETTINGS:
649 /* We save a copy of the settings since we modify
650 * if when preparing the printer job. */
651 settings = GTK_PRINT_SETTINGS (g_value_get_object (value));
652 job->settings = gtk_print_settings_copy (other: settings);
653 job->settings_set = TRUE;
654 break;
655
656 case PROP_TRACK_PRINT_STATUS:
657 gtk_print_job_set_track_print_status (job, track_status: g_value_get_boolean (value));
658 break;
659
660 default:
661 G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
662 break;
663 }
664}
665
666static void
667gtk_print_job_get_property (GObject *object,
668 guint prop_id,
669 GValue *value,
670 GParamSpec *pspec)
671{
672 GtkPrintJob *job = GTK_PRINT_JOB (object);
673
674 switch (prop_id)
675 {
676 case PROP_TITLE:
677 g_value_set_string (value, v_string: job->title);
678 break;
679 case PROP_PRINTER:
680 g_value_set_object (value, v_object: job->printer);
681 break;
682 case PROP_SETTINGS:
683 g_value_set_object (value, v_object: job->settings);
684 break;
685 case PROP_PAGE_SETUP:
686 g_value_set_object (value, v_object: job->page_setup);
687 break;
688 case PROP_TRACK_PRINT_STATUS:
689 g_value_set_boolean (value, v_boolean: job->track_print_status);
690 break;
691 default:
692 G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
693 break;
694 }
695}
696
697/**
698 * gtk_print_job_send:
699 * @job: a `GtkPrintJob`
700 * @callback: function to call when the job completes or an error occurs
701 * @user_data: (closure): user data that gets passed to @callback
702 * @dnotify: destroy notify for @user_data
703 *
704 * Sends the print job off to the printer.
705 */
706void
707gtk_print_job_send (GtkPrintJob *job,
708 GtkPrintJobCompleteFunc callback,
709 gpointer user_data,
710 GDestroyNotify dnotify)
711{
712 g_return_if_fail (GTK_IS_PRINT_JOB (job));
713 g_return_if_fail (job->spool_io != NULL);
714
715 gtk_print_job_set_status (job, status: GTK_PRINT_STATUS_SENDING_DATA);
716
717 g_io_channel_seek_position (channel: job->spool_io, offset: 0, type: G_SEEK_SET, NULL);
718
719 gtk_print_backend_print_stream (print_backend: job->backend, job,
720 data_io: job->spool_io,
721 callback, user_data, dnotify);
722}
723
724/**
725 * gtk_print_job_get_pages:
726 * @job: a `GtkPrintJob`
727 *
728 * Gets the `GtkPrintPages` setting for this job.
729 *
730 * Returns: the `GtkPrintPages` setting
731 */
732GtkPrintPages
733gtk_print_job_get_pages (GtkPrintJob *job)
734{
735 return job->print_pages;
736}
737
738/**
739 * gtk_print_job_set_pages:
740 * @job: a `GtkPrintJob`
741 * @pages: the `GtkPrintPages` setting
742 *
743 * Sets the `GtkPrintPages` setting for this job.
744 */
745void
746gtk_print_job_set_pages (GtkPrintJob *job,
747 GtkPrintPages pages)
748{
749 job->print_pages = pages;
750}
751
752/**
753 * gtk_print_job_get_page_ranges:
754 * @job: a `GtkPrintJob`
755 * @n_ranges: (out): return location for the number of ranges
756 *
757 * Gets the page ranges for this job.
758 *
759 * Returns: (array length=n_ranges) (transfer none): a pointer to an
760 * array of `GtkPageRange` structs
761 */
762GtkPageRange *
763gtk_print_job_get_page_ranges (GtkPrintJob *job,
764 int *n_ranges)
765{
766 *n_ranges = job->num_page_ranges;
767 return job->page_ranges;
768}
769
770/**
771 * gtk_print_job_set_page_ranges:
772 * @job: a `GtkPrintJob`
773 * @ranges: (array length=n_ranges) (transfer full): pointer to an array of
774 * `GtkPageRange` structs
775 * @n_ranges: the length of the @ranges array
776 *
777 * Sets the page ranges for this job.
778 */
779void
780gtk_print_job_set_page_ranges (GtkPrintJob *job,
781 GtkPageRange *ranges,
782 int n_ranges)
783{
784 g_free (mem: job->page_ranges);
785 job->page_ranges = ranges;
786 job->num_page_ranges = n_ranges;
787}
788
789/**
790 * gtk_print_job_get_page_set:
791 * @job: a `GtkPrintJob`
792 *
793 * Gets the `GtkPageSet` setting for this job.
794 *
795 * Returns: the `GtkPageSet` setting
796 */
797GtkPageSet
798gtk_print_job_get_page_set (GtkPrintJob *job)
799{
800 return job->page_set;
801}
802
803/**
804 * gtk_print_job_set_page_set:
805 * @job: a `GtkPrintJob`
806 * @page_set: a `GtkPageSet` setting
807 *
808 * Sets the `GtkPageSet` setting for this job.
809 */
810void
811gtk_print_job_set_page_set (GtkPrintJob *job,
812 GtkPageSet page_set)
813{
814 job->page_set = page_set;
815}
816
817/**
818 * gtk_print_job_get_num_copies:
819 * @job: a `GtkPrintJob`
820 *
821 * Gets the number of copies of this job.
822 *
823 * Returns: the number of copies
824 */
825int
826gtk_print_job_get_num_copies (GtkPrintJob *job)
827{
828 return job->num_copies;
829}
830
831/**
832 * gtk_print_job_set_num_copies:
833 * @job: a `GtkPrintJob`
834 * @num_copies: the number of copies
835 *
836 * Sets the number of copies for this job.
837 */
838void
839gtk_print_job_set_num_copies (GtkPrintJob *job,
840 int num_copies)
841{
842 job->num_copies = num_copies;
843}
844
845/**
846 * gtk_print_job_get_scale:
847 * @job: a `GtkPrintJob`
848 *
849 * Gets the scale for this job.
850 *
851 * Returns: the scale
852 */
853double
854gtk_print_job_get_scale (GtkPrintJob *job)
855
856{
857 return job->scale;
858}
859
860/**
861 * gtk_print_job_set_scale:
862 * @job: a `GtkPrintJob`
863 * @scale: the scale
864 *
865 * Sets the scale for this job.
866 *
867 * 1.0 means unscaled.
868 */
869void
870gtk_print_job_set_scale (GtkPrintJob *job,
871 double scale)
872{
873 job->scale = scale;
874}
875
876/**
877 * gtk_print_job_get_n_up:
878 * @job: a `GtkPrintJob`
879 *
880 * Gets the n-up setting for this job.
881 *
882 * Returns: the n-up setting
883 */
884guint
885gtk_print_job_get_n_up (GtkPrintJob *job)
886{
887 return job->number_up;
888}
889
890/**
891 * gtk_print_job_set_n_up:
892 * @job: a `GtkPrintJob`
893 * @n_up: the n-up value
894 *
895 * Sets the n-up setting for this job.
896 */
897void
898gtk_print_job_set_n_up (GtkPrintJob *job,
899 guint n_up)
900{
901 job->number_up = n_up;
902}
903
904/**
905 * gtk_print_job_get_n_up_layout:
906 * @job: a `GtkPrintJob`
907 *
908 * Gets the n-up layout setting for this job.
909 *
910 * Returns: the n-up layout
911 */
912GtkNumberUpLayout
913gtk_print_job_get_n_up_layout (GtkPrintJob *job)
914{
915 return job->number_up_layout;
916}
917
918/**
919 * gtk_print_job_set_n_up_layout:
920 * @job: a `GtkPrintJob`
921 * @layout: the n-up layout setting
922 *
923 * Sets the n-up layout setting for this job.
924 */
925void
926gtk_print_job_set_n_up_layout (GtkPrintJob *job,
927 GtkNumberUpLayout layout)
928{
929 job->number_up_layout = layout;
930}
931
932/**
933 * gtk_print_job_get_rotate:
934 * @job: a `GtkPrintJob`
935 *
936 * Gets whether the job is printed rotated.
937 *
938 * Returns: whether the job is printed rotated
939 */
940gboolean
941gtk_print_job_get_rotate (GtkPrintJob *job)
942{
943 return job->rotate_to_orientation;
944}
945
946/**
947 * gtk_print_job_set_rotate:
948 * @job: a `GtkPrintJob`
949 * @rotate: whether to print rotated
950 *
951 * Sets whether this job is printed rotated.
952 */
953void
954gtk_print_job_set_rotate (GtkPrintJob *job,
955 gboolean rotate)
956{
957 job->rotate_to_orientation = rotate;
958}
959
960/**
961 * gtk_print_job_get_collate:
962 * @job: a `GtkPrintJob`
963 *
964 * Gets whether this job is printed collated.
965 *
966 * Returns: whether the job is printed collated
967 */
968gboolean
969gtk_print_job_get_collate (GtkPrintJob *job)
970{
971 return job->collate;
972}
973
974/**
975 * gtk_print_job_set_collate:
976 * @job: a `GtkPrintJob`
977 * @collate: whether the job is printed collated
978 *
979 * Sets whether this job is printed collated.
980 */
981void
982gtk_print_job_set_collate (GtkPrintJob *job,
983 gboolean collate)
984{
985 job->collate = collate;
986}
987
988/**
989 * gtk_print_job_get_reverse:
990 * @job: a `GtkPrintJob`
991 *
992 * Gets whether this job is printed reversed.
993 *
994 * Returns: whether the job is printed reversed.
995 */
996gboolean
997gtk_print_job_get_reverse (GtkPrintJob *job)
998{
999 return job->reverse;
1000}
1001
1002/**
1003 * gtk_print_job_set_reverse:
1004 * @job: a `GtkPrintJob`
1005 * @reverse: whether the job is printed reversed
1006 *
1007 * Sets whether this job is printed reversed.
1008 */
1009void
1010gtk_print_job_set_reverse (GtkPrintJob *job,
1011 gboolean reverse)
1012{
1013 job->reverse = reverse;
1014}
1015

source code of gtk/gtk/gtkprintjob.c