2 * Copyright (C) 2006 John (J5) Palmieri <johnp@redhat.com>
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.
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.
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/>.
24 #include "gtkprivate.h"
26 #include "gtkprinter.h"
27 #include "gtkprinter-private.h"
28 #include "gtkprintbackend.h"
29 #include "gtkprintjob.h"
33 * @Short_description: Represents a printer
36 * A #GtkPrinter object represents a printer. You only need to
37 * deal directly with printers if you use the non-portable
38 * #GtkPrintUnixDialog API.
40 * A #GtkPrinter allows to get status information about the printer,
41 * such as its description, its location, the number of queued jobs,
42 * etc. Most importantly, a #GtkPrinter object can be used to create
43 * a #GtkPrintJob object, which lets you print to the printer.
45 * Printing support was added in GTK+ 2.10.
49 static void gtk_printer_finalize (GObject *object);
51 struct _GtkPrinterPrivate
60 guint is_accepting_jobs : 1;
64 guint has_details : 1;
65 guint accepts_pdf : 1;
71 GtkPrintBackend *backend;
94 static guint signals[LAST_SIGNAL] = { 0 };
96 static void gtk_printer_set_property (GObject *object,
100 static void gtk_printer_get_property (GObject *object,
105 G_DEFINE_TYPE (GtkPrinter, gtk_printer, G_TYPE_OBJECT)
108 gtk_printer_class_init (GtkPrinterClass *class)
110 GObjectClass *object_class;
111 object_class = (GObjectClass *) class;
113 object_class->finalize = gtk_printer_finalize;
115 object_class->set_property = gtk_printer_set_property;
116 object_class->get_property = gtk_printer_get_property;
118 g_type_class_add_private (class, sizeof (GtkPrinterPrivate));
120 g_object_class_install_property (G_OBJECT_CLASS (class),
122 g_param_spec_string ("name",
124 P_("Name of the printer"),
126 GTK_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY));
127 g_object_class_install_property (G_OBJECT_CLASS (class),
129 g_param_spec_object ("backend",
131 P_("Backend for the printer"),
132 GTK_TYPE_PRINT_BACKEND,
133 GTK_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY));
134 g_object_class_install_property (G_OBJECT_CLASS (class),
136 g_param_spec_boolean ("is-virtual",
138 P_("FALSE if this represents a real hardware printer"),
140 GTK_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY));
141 g_object_class_install_property (G_OBJECT_CLASS (class),
143 g_param_spec_boolean ("accepts-pdf",
145 P_("TRUE if this printer can accept PDF"),
147 GTK_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY));
148 g_object_class_install_property (G_OBJECT_CLASS (class),
150 g_param_spec_boolean ("accepts-ps",
151 P_("Accepts PostScript"),
152 P_("TRUE if this printer can accept PostScript"),
154 GTK_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY));
155 g_object_class_install_property (G_OBJECT_CLASS (class),
157 g_param_spec_string ("state-message",
159 P_("String giving the current state of the printer"),
161 GTK_PARAM_READABLE));
162 g_object_class_install_property (G_OBJECT_CLASS (class),
164 g_param_spec_string ("location",
166 P_("The location of the printer"),
168 GTK_PARAM_READABLE));
169 g_object_class_install_property (G_OBJECT_CLASS (class),
171 g_param_spec_string ("icon-name",
173 P_("The icon name to use for the printer"),
175 GTK_PARAM_READABLE));
176 g_object_class_install_property (G_OBJECT_CLASS (class),
178 g_param_spec_int ("job-count",
180 P_("Number of jobs queued in the printer"),
184 GTK_PARAM_READABLE));
189 * This property is %TRUE if this printer is paused.
190 * A paused printer still accepts jobs, but it does
195 g_object_class_install_property (G_OBJECT_CLASS (class),
197 g_param_spec_boolean ("paused",
198 P_("Paused Printer"),
199 P_("TRUE if this printer is paused"),
201 GTK_PARAM_READABLE));
203 * GtkPrinter:accepting-jobs:
205 * This property is %TRUE if the printer is accepting jobs.
209 g_object_class_install_property (G_OBJECT_CLASS (class),
211 g_param_spec_boolean ("accepting-jobs",
212 P_("Accepting Jobs"),
213 P_("TRUE if this printer is accepting new jobs"),
215 GTK_PARAM_READABLE));
218 * GtkPrinter::details-acquired:
219 * @printer: the #GtkPrinter on which the signal is emitted
220 * @success: %TRUE if the details were successfully acquired
222 * Gets emitted in response to a request for detailed information
223 * about a printer from the print backend. The @success parameter
224 * indicates if the information was actually obtained.
228 signals[DETAILS_ACQUIRED] =
229 g_signal_new (I_("details-acquired"),
230 G_TYPE_FROM_CLASS (class),
232 G_STRUCT_OFFSET (GtkPrinterClass, details_acquired),
234 g_cclosure_marshal_VOID__BOOLEAN,
235 G_TYPE_NONE, 1, G_TYPE_BOOLEAN);
239 gtk_printer_init (GtkPrinter *printer)
241 GtkPrinterPrivate *priv;
243 priv = printer->priv = G_TYPE_INSTANCE_GET_PRIVATE (printer,
248 priv->location = NULL;
249 priv->description = NULL;
250 priv->icon_name = NULL;
252 priv->is_active = TRUE;
253 priv->is_paused = FALSE;
254 priv->is_accepting_jobs = TRUE;
256 priv->has_details = FALSE;
257 priv->accepts_pdf = FALSE;
258 priv->accepts_ps = TRUE;
260 priv->state_message = NULL;
265 gtk_printer_finalize (GObject *object)
267 GtkPrinter *printer = GTK_PRINTER (object);
268 GtkPrinterPrivate *priv = printer->priv;
271 g_free (priv->location);
272 g_free (priv->description);
273 g_free (priv->state_message);
274 g_free (priv->icon_name);
277 g_object_unref (priv->backend);
279 G_OBJECT_CLASS (gtk_printer_parent_class)->finalize (object);
283 gtk_printer_set_property (GObject *object,
288 GtkPrinter *printer = GTK_PRINTER (object);
289 GtkPrinterPrivate *priv = printer->priv;
294 priv->name = g_value_dup_string (value);
298 priv->backend = GTK_PRINT_BACKEND (g_value_dup_object (value));
301 case PROP_IS_VIRTUAL:
302 priv->is_virtual = g_value_get_boolean (value);
305 case PROP_ACCEPTS_PDF:
306 priv->accepts_pdf = g_value_get_boolean (value);
309 case PROP_ACCEPTS_PS:
310 priv->accepts_ps = g_value_get_boolean (value);
314 G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
320 gtk_printer_get_property (GObject *object,
325 GtkPrinter *printer = GTK_PRINTER (object);
326 GtkPrinterPrivate *priv = printer->priv;
332 g_value_set_string (value, priv->name);
334 g_value_set_static_string (value, "");
337 g_value_set_object (value, priv->backend);
339 case PROP_STATE_MESSAGE:
340 if (priv->state_message)
341 g_value_set_string (value, priv->state_message);
343 g_value_set_static_string (value, "");
347 g_value_set_string (value, priv->location);
349 g_value_set_static_string (value, "");
353 g_value_set_string (value, priv->icon_name);
355 g_value_set_static_string (value, "");
358 g_value_set_int (value, priv->job_count);
360 case PROP_IS_VIRTUAL:
361 g_value_set_boolean (value, priv->is_virtual);
363 case PROP_ACCEPTS_PDF:
364 g_value_set_boolean (value, priv->accepts_pdf);
366 case PROP_ACCEPTS_PS:
367 g_value_set_boolean (value, priv->accepts_ps);
370 g_value_set_boolean (value, priv->is_paused);
372 case PROP_ACCEPTING_JOBS:
373 g_value_set_boolean (value, priv->is_accepting_jobs);
376 G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
383 * @name: the name of the printer
384 * @backend: a #GtkPrintBackend
385 * @virtual_: whether the printer is virtual
387 * Creates a new #GtkPrinter.
389 * Return value: a new #GtkPrinter
394 gtk_printer_new (const gchar *name,
395 GtkPrintBackend *backend,
400 result = g_object_new (GTK_TYPE_PRINTER,
403 "is-virtual", virtual_,
406 return (GtkPrinter *) result;
410 * gtk_printer_get_backend:
411 * @printer: a #GtkPrinter
413 * Returns the backend of the printer.
415 * Return value: (transfer none): the backend of @printer
420 gtk_printer_get_backend (GtkPrinter *printer)
422 g_return_val_if_fail (GTK_IS_PRINTER (printer), NULL);
424 return printer->priv->backend;
428 * gtk_printer_get_name:
429 * @printer: a #GtkPrinter
431 * Returns the name of the printer.
433 * Return value: the name of @printer
438 gtk_printer_get_name (GtkPrinter *printer)
440 g_return_val_if_fail (GTK_IS_PRINTER (printer), NULL);
442 return printer->priv->name;
446 * gtk_printer_get_description:
447 * @printer: a #GtkPrinter
449 * Gets the description of the printer.
451 * Return value: the description of @printer
456 gtk_printer_get_description (GtkPrinter *printer)
458 g_return_val_if_fail (GTK_IS_PRINTER (printer), NULL);
460 return printer->priv->description;
464 gtk_printer_set_description (GtkPrinter *printer,
465 const gchar *description)
467 GtkPrinterPrivate *priv;
469 g_return_val_if_fail (GTK_IS_PRINTER (printer), FALSE);
471 priv = printer->priv;
473 if (g_strcmp0 (priv->description, description) == 0)
476 g_free (priv->description);
477 priv->description = g_strdup (description);
483 * gtk_printer_get_state_message:
484 * @printer: a #GtkPrinter
486 * Returns the state message describing the current state
489 * Return value: the state message of @printer
494 gtk_printer_get_state_message (GtkPrinter *printer)
496 g_return_val_if_fail (GTK_IS_PRINTER (printer), NULL);
498 return printer->priv->state_message;
502 gtk_printer_set_state_message (GtkPrinter *printer,
503 const gchar *message)
505 GtkPrinterPrivate *priv;
507 g_return_val_if_fail (GTK_IS_PRINTER (printer), FALSE);
509 priv = printer->priv;
511 if (g_strcmp0 (priv->state_message, message) == 0)
514 g_free (priv->state_message);
515 priv->state_message = g_strdup (message);
516 g_object_notify (G_OBJECT (printer), "state-message");
522 * gtk_printer_get_location:
523 * @printer: a #GtkPrinter
525 * Returns a description of the location of the printer.
527 * Return value: the location of @printer
532 gtk_printer_get_location (GtkPrinter *printer)
534 g_return_val_if_fail (GTK_IS_PRINTER (printer), NULL);
536 return printer->priv->location;
540 gtk_printer_set_location (GtkPrinter *printer,
541 const gchar *location)
543 GtkPrinterPrivate *priv;
545 g_return_val_if_fail (GTK_IS_PRINTER (printer), FALSE);
547 priv = printer->priv;
549 if (g_strcmp0 (priv->location, location) == 0)
552 g_free (priv->location);
553 priv->location = g_strdup (location);
554 g_object_notify (G_OBJECT (printer), "location");
560 * gtk_printer_get_icon_name:
561 * @printer: a #GtkPrinter
563 * Gets the name of the icon to use for the printer.
565 * Return value: the icon name for @printer
570 gtk_printer_get_icon_name (GtkPrinter *printer)
572 g_return_val_if_fail (GTK_IS_PRINTER (printer), NULL);
574 return printer->priv->icon_name;
578 gtk_printer_set_icon_name (GtkPrinter *printer,
581 GtkPrinterPrivate *priv;
583 g_return_if_fail (GTK_IS_PRINTER (printer));
585 priv = printer->priv;
587 g_free (priv->icon_name);
588 priv->icon_name = g_strdup (icon);
589 g_object_notify (G_OBJECT (printer), "icon-name");
593 * gtk_printer_get_job_count:
594 * @printer: a #GtkPrinter
596 * Gets the number of jobs currently queued on the printer.
598 * Return value: the number of jobs on @printer
603 gtk_printer_get_job_count (GtkPrinter *printer)
605 g_return_val_if_fail (GTK_IS_PRINTER (printer), 0);
607 return printer->priv->job_count;
611 gtk_printer_set_job_count (GtkPrinter *printer,
614 GtkPrinterPrivate *priv;
616 g_return_val_if_fail (GTK_IS_PRINTER (printer), FALSE);
618 priv = printer->priv;
620 if (priv->job_count == count)
623 priv->job_count = count;
625 g_object_notify (G_OBJECT (printer), "job-count");
631 * gtk_printer_has_details:
632 * @printer: a #GtkPrinter
634 * Returns whether the printer details are available.
636 * Return value: %TRUE if @printer details are available
641 gtk_printer_has_details (GtkPrinter *printer)
643 g_return_val_if_fail (GTK_IS_PRINTER (printer), FALSE);
645 return printer->priv->has_details;
649 gtk_printer_set_has_details (GtkPrinter *printer,
652 printer->priv->has_details = val;
656 * gtk_printer_is_active:
657 * @printer: a #GtkPrinter
659 * Returns whether the printer is currently active (i.e.
662 * Return value: %TRUE if @printer is active
667 gtk_printer_is_active (GtkPrinter *printer)
669 g_return_val_if_fail (GTK_IS_PRINTER (printer), TRUE);
671 return printer->priv->is_active;
675 gtk_printer_set_is_active (GtkPrinter *printer,
678 g_return_if_fail (GTK_IS_PRINTER (printer));
680 printer->priv->is_active = val;
684 * gtk_printer_is_paused:
685 * @printer: a #GtkPrinter
687 * Returns whether the printer is currently paused.
688 * A paused printer still accepts jobs, but it is not
691 * Return value: %TRUE if @printer is paused
696 gtk_printer_is_paused (GtkPrinter *printer)
698 g_return_val_if_fail (GTK_IS_PRINTER (printer), TRUE);
700 return printer->priv->is_paused;
704 gtk_printer_set_is_paused (GtkPrinter *printer,
707 GtkPrinterPrivate *priv;
709 g_return_val_if_fail (GTK_IS_PRINTER (printer), FALSE);
711 priv = printer->priv;
713 if (val == priv->is_paused)
716 priv->is_paused = val;
722 * gtk_printer_is_accepting_jobs:
723 * @printer: a #GtkPrinter
725 * Returns whether the printer is accepting jobs
727 * Return value: %TRUE if @printer is accepting jobs
732 gtk_printer_is_accepting_jobs (GtkPrinter *printer)
734 g_return_val_if_fail (GTK_IS_PRINTER (printer), TRUE);
736 return printer->priv->is_accepting_jobs;
740 gtk_printer_set_is_accepting_jobs (GtkPrinter *printer,
743 GtkPrinterPrivate *priv;
745 g_return_val_if_fail (GTK_IS_PRINTER (printer), FALSE);
747 priv = printer->priv;
749 if (val == priv->is_accepting_jobs)
752 priv->is_accepting_jobs = val;
758 * gtk_printer_is_virtual:
759 * @printer: a #GtkPrinter
761 * Returns whether the printer is virtual (i.e. does not
762 * represent actual printer hardware, but something like
765 * Return value: %TRUE if @printer is virtual
770 gtk_printer_is_virtual (GtkPrinter *printer)
772 g_return_val_if_fail (GTK_IS_PRINTER (printer), TRUE);
774 return printer->priv->is_virtual;
778 * gtk_printer_accepts_pdf:
779 * @printer: a #GtkPrinter
781 * Returns whether the printer accepts input in
784 * Return value: %TRUE if @printer accepts PDF
789 gtk_printer_accepts_pdf (GtkPrinter *printer)
791 g_return_val_if_fail (GTK_IS_PRINTER (printer), TRUE);
793 return printer->priv->accepts_pdf;
797 gtk_printer_set_accepts_pdf (GtkPrinter *printer,
800 g_return_if_fail (GTK_IS_PRINTER (printer));
802 printer->priv->accepts_pdf = val;
806 * gtk_printer_accepts_ps:
807 * @printer: a #GtkPrinter
809 * Returns whether the printer accepts input in
812 * Return value: %TRUE if @printer accepts PostScript
817 gtk_printer_accepts_ps (GtkPrinter *printer)
819 g_return_val_if_fail (GTK_IS_PRINTER (printer), TRUE);
821 return printer->priv->accepts_ps;
825 gtk_printer_set_accepts_ps (GtkPrinter *printer,
828 g_return_if_fail (GTK_IS_PRINTER (printer));
830 printer->priv->accepts_ps = val;
834 gtk_printer_is_new (GtkPrinter *printer)
836 g_return_val_if_fail (GTK_IS_PRINTER (printer), FALSE);
838 return printer->priv->is_new;
842 gtk_printer_set_is_new (GtkPrinter *printer,
845 g_return_if_fail (GTK_IS_PRINTER (printer));
847 printer->priv->is_new = val;
852 * gtk_printer_is_default:
853 * @printer: a #GtkPrinter
855 * Returns whether the printer is the default printer.
857 * Return value: %TRUE if @printer is the default
862 gtk_printer_is_default (GtkPrinter *printer)
864 g_return_val_if_fail (GTK_IS_PRINTER (printer), FALSE);
866 return printer->priv->is_default;
870 gtk_printer_set_is_default (GtkPrinter *printer,
873 g_return_if_fail (GTK_IS_PRINTER (printer));
875 printer->priv->is_default = val;
879 * gtk_printer_request_details:
880 * @printer: a #GtkPrinter
882 * Requests the printer details. When the details are available,
883 * the #GtkPrinter::details-acquired signal will be emitted on @printer.
888 gtk_printer_request_details (GtkPrinter *printer)
890 GtkPrintBackendClass *backend_class;
892 g_return_if_fail (GTK_IS_PRINTER (printer));
894 backend_class = GTK_PRINT_BACKEND_GET_CLASS (printer->priv->backend);
895 backend_class->printer_request_details (printer);
898 GtkPrinterOptionSet *
899 _gtk_printer_get_options (GtkPrinter *printer,
900 GtkPrintSettings *settings,
901 GtkPageSetup *page_setup,
902 GtkPrintCapabilities capabilities)
904 GtkPrintBackendClass *backend_class = GTK_PRINT_BACKEND_GET_CLASS (printer->priv->backend);
905 return backend_class->printer_get_options (printer, settings, page_setup, capabilities);
909 _gtk_printer_mark_conflicts (GtkPrinter *printer,
910 GtkPrinterOptionSet *options)
912 GtkPrintBackendClass *backend_class = GTK_PRINT_BACKEND_GET_CLASS (printer->priv->backend);
913 return backend_class->printer_mark_conflicts (printer, options);
917 _gtk_printer_get_settings_from_options (GtkPrinter *printer,
918 GtkPrinterOptionSet *options,
919 GtkPrintSettings *settings)
921 GtkPrintBackendClass *backend_class = GTK_PRINT_BACKEND_GET_CLASS (printer->priv->backend);
922 backend_class->printer_get_settings_from_options (printer, options, settings);
926 _gtk_printer_prepare_for_print (GtkPrinter *printer,
927 GtkPrintJob *print_job,
928 GtkPrintSettings *settings,
929 GtkPageSetup *page_setup)
931 GtkPrintBackendClass *backend_class = GTK_PRINT_BACKEND_GET_CLASS (printer->priv->backend);
932 backend_class->printer_prepare_for_print (printer, print_job, settings, page_setup);
936 _gtk_printer_create_cairo_surface (GtkPrinter *printer,
937 GtkPrintSettings *settings,
940 GIOChannel *cache_io)
942 GtkPrintBackendClass *backend_class = GTK_PRINT_BACKEND_GET_CLASS (printer->priv->backend);
944 return backend_class->printer_create_cairo_surface (printer, settings,
945 width, height, cache_io);
949 * gtk_printer_list_papers:
950 * @printer: a #GtkPrinter
952 * Lists all the paper sizes @printer supports.
953 * This will return and empty list unless the printer's details are
954 * available, see gtk_printer_has_details() and gtk_printer_request_details().
956 * Return value: (element-type GtkPageSetup) (transfer full): a newly allocated list of newly allocated #GtkPageSetup s.
961 gtk_printer_list_papers (GtkPrinter *printer)
963 GtkPrintBackendClass *backend_class;
965 g_return_val_if_fail (GTK_IS_PRINTER (printer), NULL);
967 backend_class = GTK_PRINT_BACKEND_GET_CLASS (printer->priv->backend);
968 return backend_class->printer_list_papers (printer);
972 * gtk_printer_get_default_page_size:
973 * @printer: a #GtkPrinter
975 * Returns default page size of @printer.
977 * Return value: a newly allocated #GtkPageSetup with default page size of the printer.
982 gtk_printer_get_default_page_size (GtkPrinter *printer)
984 GtkPrintBackendClass *backend_class;
986 g_return_val_if_fail (GTK_IS_PRINTER (printer), NULL);
988 backend_class = GTK_PRINT_BACKEND_GET_CLASS (printer->priv->backend);
989 return backend_class->printer_get_default_page_size (printer);
993 * gtk_printer_get_hard_margins:
994 * @printer: a #GtkPrinter
995 * @top: (out): a location to store the top margin in
996 * @bottom: (out): a location to store the bottom margin in
997 * @left: (out): a location to store the left margin in
998 * @right: (out): a location to store the right margin in
1000 * Retrieve the hard margins of @printer, i.e. the margins that define
1001 * the area at the borders of the paper that the printer cannot print to.
1003 * Note: This will not succeed unless the printer's details are available,
1004 * see gtk_printer_has_details() and gtk_printer_request_details().
1006 * Return value: %TRUE iff the hard margins were retrieved
1011 gtk_printer_get_hard_margins (GtkPrinter *printer,
1017 GtkPrintBackendClass *backend_class = GTK_PRINT_BACKEND_GET_CLASS (printer->priv->backend);
1019 return backend_class->printer_get_hard_margins (printer, top, bottom, left, right);
1023 * gtk_printer_get_capabilities:
1024 * @printer: a #GtkPrinter
1026 * Returns the printer's capabilities.
1028 * This is useful when you're using #GtkPrintUnixDialog's manual-capabilities
1029 * setting and need to know which settings the printer can handle and which
1030 * you must handle yourself.
1032 * This will return 0 unless the printer's details are available, see
1033 * gtk_printer_has_details() and gtk_printer_request_details().
1035 * Return value: the printer's capabilities
1039 GtkPrintCapabilities
1040 gtk_printer_get_capabilities (GtkPrinter *printer)
1042 GtkPrintBackendClass *backend_class;
1044 g_return_val_if_fail (GTK_IS_PRINTER (printer), 0);
1046 backend_class = GTK_PRINT_BACKEND_GET_CLASS (printer->priv->backend);
1047 return backend_class->printer_get_capabilities (printer);
1051 * gtk_printer_compare:
1053 * @b: another #GtkPrinter
1055 * Compares two printers.
1057 * Return value: 0 if the printer match, a negative value if @a < @b,
1058 * or a positive value if @a > @b
1063 gtk_printer_compare (GtkPrinter *a,
1066 const char *name_a, *name_b;
1068 g_assert (GTK_IS_PRINTER (a) && GTK_IS_PRINTER (b));
1070 name_a = gtk_printer_get_name (a);
1071 name_b = gtk_printer_get_name (b);
1072 if (name_a == NULL && name_b == NULL)
1074 else if (name_a == NULL)
1076 else if (name_b == NULL)
1079 return g_ascii_strcasecmp (name_a, name_b);
1086 GtkPrinterFunc func;
1088 GDestroyNotify destroy;
1092 static void list_done_cb (GtkPrintBackend *backend,
1093 PrinterList *printer_list);
1096 stop_enumeration (PrinterList *printer_list)
1099 GtkPrintBackend *backend;
1101 for (list = printer_list->backends; list; list = next)
1104 backend = GTK_PRINT_BACKEND (list->data);
1105 list_done_cb (backend, printer_list);
1110 free_printer_list (PrinterList *printer_list)
1112 if (printer_list->destroy)
1113 printer_list->destroy (printer_list->data);
1115 if (printer_list->loop)
1117 g_main_loop_quit (printer_list->loop);
1118 g_main_loop_unref (printer_list->loop);
1121 g_free (printer_list);
1125 list_added_cb (GtkPrintBackend *backend,
1126 GtkPrinter *printer,
1127 PrinterList *printer_list)
1129 if (printer_list->func (printer, printer_list->data))
1131 stop_enumeration (printer_list);
1139 backend_status_changed (GObject *object,
1143 GtkPrintBackend *backend = GTK_PRINT_BACKEND (object);
1144 PrinterList *printer_list = data;
1145 GtkPrintBackendStatus status;
1147 g_object_get (backend, "status", &status, NULL);
1149 if (status == GTK_PRINT_BACKEND_STATUS_UNAVAILABLE)
1150 list_done_cb (backend, printer_list);
1154 list_printers_remove_backend (PrinterList *printer_list,
1155 GtkPrintBackend *backend)
1157 printer_list->backends = g_list_remove (printer_list->backends, backend);
1158 gtk_print_backend_destroy (backend);
1159 g_object_unref (backend);
1161 if (printer_list->backends == NULL)
1162 free_printer_list (printer_list);
1166 list_done_cb (GtkPrintBackend *backend,
1167 PrinterList *printer_list)
1169 g_signal_handlers_disconnect_by_func (backend, list_added_cb, printer_list);
1170 g_signal_handlers_disconnect_by_func (backend, list_done_cb, printer_list);
1171 g_signal_handlers_disconnect_by_func (backend, backend_status_changed, printer_list);
1173 list_printers_remove_backend(printer_list, backend);
1177 list_printers_init (PrinterList *printer_list,
1178 GtkPrintBackend *backend)
1181 GtkPrintBackendStatus status;
1183 list = gtk_print_backend_get_printer_list (backend);
1185 for (node = list; node != NULL; node = node->next)
1187 if (list_added_cb (backend, node->data, printer_list))
1196 g_object_get (backend, "status", &status, NULL);
1198 if (status == GTK_PRINT_BACKEND_STATUS_UNAVAILABLE ||
1199 gtk_print_backend_printer_list_is_done (backend))
1200 list_printers_remove_backend(printer_list, backend);
1203 g_signal_connect (backend, "printer-added",
1204 (GCallback) list_added_cb,
1206 g_signal_connect (backend, "printer-list-done",
1207 (GCallback) list_done_cb,
1209 g_signal_connect (backend, "notify::status",
1210 (GCallback) backend_status_changed,
1218 * gtk_enumerate_printers:
1219 * @func: a function to call for each printer
1220 * @data: user data to pass to @func
1221 * @destroy: function to call if @data is no longer needed
1222 * @wait: if %TRUE, wait in a recursive mainloop until
1223 * all printers are enumerated; otherwise return early
1225 * Calls a function for all #GtkPrinter<!-- -->s.
1226 * If @func returns %TRUE, the enumeration is stopped.
1231 gtk_enumerate_printers (GtkPrinterFunc func,
1233 GDestroyNotify destroy,
1236 PrinterList *printer_list;
1238 GtkPrintBackend *backend;
1240 printer_list = g_new0 (PrinterList, 1);
1242 printer_list->func = func;
1243 printer_list->data = data;
1244 printer_list->destroy = destroy;
1246 if (g_module_supported ())
1247 printer_list->backends = gtk_print_backend_load_modules ();
1249 if (printer_list->backends == NULL)
1251 free_printer_list (printer_list);
1255 for (node = printer_list->backends; node != NULL; node = next)
1258 backend = GTK_PRINT_BACKEND (node->data);
1259 if (list_printers_init (printer_list, backend))
1263 if (wait && printer_list->backends)
1265 printer_list->loop = g_main_loop_new (NULL, FALSE);
1267 gdk_threads_leave ();
1268 g_main_loop_run (printer_list->loop);
1269 gdk_threads_enter ();
1274 gtk_print_capabilities_get_type (void)
1276 static GType etype = 0;
1278 if (G_UNLIKELY (etype == 0))
1280 static const GFlagsValue values[] = {
1281 { GTK_PRINT_CAPABILITY_PAGE_SET, "GTK_PRINT_CAPABILITY_PAGE_SET", "page-set" },
1282 { GTK_PRINT_CAPABILITY_COPIES, "GTK_PRINT_CAPABILITY_COPIES", "copies" },
1283 { GTK_PRINT_CAPABILITY_COLLATE, "GTK_PRINT_CAPABILITY_COLLATE", "collate" },
1284 { GTK_PRINT_CAPABILITY_REVERSE, "GTK_PRINT_CAPABILITY_REVERSE", "reverse" },
1285 { GTK_PRINT_CAPABILITY_SCALE, "GTK_PRINT_CAPABILITY_SCALE", "scale" },
1286 { GTK_PRINT_CAPABILITY_GENERATE_PDF, "GTK_PRINT_CAPABILITY_GENERATE_PDF", "generate-pdf" },
1287 { GTK_PRINT_CAPABILITY_GENERATE_PS, "GTK_PRINT_CAPABILITY_GENERATE_PS", "generate-ps" },
1288 { GTK_PRINT_CAPABILITY_PREVIEW, "GTK_PRINT_CAPABILITY_PREVIEW", "preview" },
1289 { GTK_PRINT_CAPABILITY_NUMBER_UP, "GTK_PRINT_CAPABILITY_NUMBER_UP", "number-up"},
1290 { GTK_PRINT_CAPABILITY_NUMBER_UP_LAYOUT, "GTK_PRINT_CAPABILITY_NUMBER_UP_LAYOUT", "number-up-layout" },
1294 etype = g_flags_register_static (I_("GtkPrintCapabilities"), values);