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, write to the
16 * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
17 * Boston, MA 02111-1307, USA.
26 #include "gtkprivate.h"
28 #include "gtkprinter.h"
29 #include "gtkprinter-private.h"
30 #include "gtkprintbackend.h"
31 #include "gtkprintjob.h"
35 * @Short_description: Represents a printer
38 * A #GtkPrinter object represents a printer. You only need to
39 * deal directly with printers if you use the non-portable
40 * #GtkPrintUnixDialog API.
42 * A #GtkPrinter allows to get status information about the printer,
43 * such as its description, its location, the number of queued jobs,
44 * etc. Most importantly, a #GtkPrinter object can be used to create
45 * a #GtkPrintJob object, which lets you print to the printer.
47 * Printing support was added in GTK+ 2.10.
51 static void gtk_printer_finalize (GObject *object);
53 struct _GtkPrinterPrivate
62 guint is_accepting_jobs : 1;
66 guint has_details : 1;
67 guint accepts_pdf : 1;
73 GtkPrintBackend *backend;
96 static guint signals[LAST_SIGNAL] = { 0 };
98 static void gtk_printer_set_property (GObject *object,
102 static void gtk_printer_get_property (GObject *object,
107 G_DEFINE_TYPE (GtkPrinter, gtk_printer, G_TYPE_OBJECT)
110 gtk_printer_class_init (GtkPrinterClass *class)
112 GObjectClass *object_class;
113 object_class = (GObjectClass *) class;
115 object_class->finalize = gtk_printer_finalize;
117 object_class->set_property = gtk_printer_set_property;
118 object_class->get_property = gtk_printer_get_property;
120 g_type_class_add_private (class, sizeof (GtkPrinterPrivate));
122 g_object_class_install_property (G_OBJECT_CLASS (class),
124 g_param_spec_string ("name",
126 P_("Name of the printer"),
128 GTK_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY));
129 g_object_class_install_property (G_OBJECT_CLASS (class),
131 g_param_spec_object ("backend",
133 P_("Backend for the printer"),
134 GTK_TYPE_PRINT_BACKEND,
135 GTK_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY));
136 g_object_class_install_property (G_OBJECT_CLASS (class),
138 g_param_spec_boolean ("is-virtual",
140 P_("FALSE if this represents a real hardware printer"),
142 GTK_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY));
143 g_object_class_install_property (G_OBJECT_CLASS (class),
145 g_param_spec_boolean ("accepts-pdf",
147 P_("TRUE if this printer can accept PDF"),
149 GTK_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY));
150 g_object_class_install_property (G_OBJECT_CLASS (class),
152 g_param_spec_boolean ("accepts-ps",
153 P_("Accepts PostScript"),
154 P_("TRUE if this printer can accept PostScript"),
156 GTK_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY));
157 g_object_class_install_property (G_OBJECT_CLASS (class),
159 g_param_spec_string ("state-message",
161 P_("String giving the current state of the printer"),
163 GTK_PARAM_READABLE));
164 g_object_class_install_property (G_OBJECT_CLASS (class),
166 g_param_spec_string ("location",
168 P_("The location of the printer"),
170 GTK_PARAM_READABLE));
171 g_object_class_install_property (G_OBJECT_CLASS (class),
173 g_param_spec_string ("icon-name",
175 P_("The icon name to use for the printer"),
177 GTK_PARAM_READABLE));
178 g_object_class_install_property (G_OBJECT_CLASS (class),
180 g_param_spec_int ("job-count",
182 P_("Number of jobs queued in the printer"),
186 GTK_PARAM_READABLE));
191 * This property is %TRUE if this printer is paused.
192 * A paused printer still accepts jobs, but it does
197 g_object_class_install_property (G_OBJECT_CLASS (class),
199 g_param_spec_boolean ("paused",
200 P_("Paused Printer"),
201 P_("TRUE if this printer is paused"),
203 GTK_PARAM_READABLE));
205 * GtkPrinter:accepting-jobs:
207 * This property is %TRUE if the printer is accepting jobs.
211 g_object_class_install_property (G_OBJECT_CLASS (class),
213 g_param_spec_boolean ("accepting-jobs",
214 P_("Accepting Jobs"),
215 P_("TRUE if this printer is accepting new jobs"),
217 GTK_PARAM_READABLE));
220 * GtkPrinter::details-acquired:
221 * @printer: the #GtkPrinter on which the signal is emitted
222 * @success: %TRUE if the details were successfully acquired
224 * Gets emitted in response to a request for detailed information
225 * about a printer from the print backend. The @success parameter
226 * indicates if the information was actually obtained.
230 signals[DETAILS_ACQUIRED] =
231 g_signal_new (I_("details-acquired"),
232 G_TYPE_FROM_CLASS (class),
234 G_STRUCT_OFFSET (GtkPrinterClass, details_acquired),
236 g_cclosure_marshal_VOID__BOOLEAN,
237 G_TYPE_NONE, 1, G_TYPE_BOOLEAN);
241 gtk_printer_init (GtkPrinter *printer)
243 GtkPrinterPrivate *priv;
245 priv = printer->priv = G_TYPE_INSTANCE_GET_PRIVATE (printer,
250 priv->location = NULL;
251 priv->description = NULL;
252 priv->icon_name = NULL;
254 priv->is_active = TRUE;
255 priv->is_paused = FALSE;
256 priv->is_accepting_jobs = TRUE;
258 priv->has_details = FALSE;
259 priv->accepts_pdf = FALSE;
260 priv->accepts_ps = TRUE;
262 priv->state_message = NULL;
267 gtk_printer_finalize (GObject *object)
269 GtkPrinter *printer = GTK_PRINTER (object);
270 GtkPrinterPrivate *priv = printer->priv;
273 g_free (priv->location);
274 g_free (priv->description);
275 g_free (priv->state_message);
276 g_free (priv->icon_name);
279 g_object_unref (priv->backend);
281 G_OBJECT_CLASS (gtk_printer_parent_class)->finalize (object);
285 gtk_printer_set_property (GObject *object,
290 GtkPrinter *printer = GTK_PRINTER (object);
291 GtkPrinterPrivate *priv = printer->priv;
296 priv->name = g_value_dup_string (value);
300 priv->backend = GTK_PRINT_BACKEND (g_value_dup_object (value));
303 case PROP_IS_VIRTUAL:
304 priv->is_virtual = g_value_get_boolean (value);
307 case PROP_ACCEPTS_PDF:
308 priv->accepts_pdf = g_value_get_boolean (value);
311 case PROP_ACCEPTS_PS:
312 priv->accepts_ps = g_value_get_boolean (value);
316 G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
322 gtk_printer_get_property (GObject *object,
327 GtkPrinter *printer = GTK_PRINTER (object);
328 GtkPrinterPrivate *priv = printer->priv;
334 g_value_set_string (value, priv->name);
336 g_value_set_static_string (value, "");
339 g_value_set_object (value, priv->backend);
341 case PROP_STATE_MESSAGE:
342 if (priv->state_message)
343 g_value_set_string (value, priv->state_message);
345 g_value_set_static_string (value, "");
349 g_value_set_string (value, priv->location);
351 g_value_set_static_string (value, "");
355 g_value_set_string (value, priv->icon_name);
357 g_value_set_static_string (value, "");
360 g_value_set_int (value, priv->job_count);
362 case PROP_IS_VIRTUAL:
363 g_value_set_boolean (value, priv->is_virtual);
365 case PROP_ACCEPTS_PDF:
366 g_value_set_boolean (value, priv->accepts_pdf);
368 case PROP_ACCEPTS_PS:
369 g_value_set_boolean (value, priv->accepts_ps);
372 g_value_set_boolean (value, priv->is_paused);
374 case PROP_ACCEPTING_JOBS:
375 g_value_set_boolean (value, priv->is_accepting_jobs);
378 G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
385 * @name: the name of the printer
386 * @backend: a #GtkPrintBackend
387 * @virtual_: whether the printer is virtual
389 * Creates a new #GtkPrinter.
391 * Return value: a new #GtkPrinter
396 gtk_printer_new (const gchar *name,
397 GtkPrintBackend *backend,
402 result = g_object_new (GTK_TYPE_PRINTER,
405 "is-virtual", virtual_,
408 return (GtkPrinter *) result;
412 * gtk_printer_get_backend:
413 * @printer: a #GtkPrinter
415 * Returns the backend of the printer.
417 * Return value: (transfer none): the backend of @printer
422 gtk_printer_get_backend (GtkPrinter *printer)
424 g_return_val_if_fail (GTK_IS_PRINTER (printer), NULL);
426 return printer->priv->backend;
430 * gtk_printer_get_name:
431 * @printer: a #GtkPrinter
433 * Returns the name of the printer.
435 * Return value: the name of @printer
439 G_CONST_RETURN gchar *
440 gtk_printer_get_name (GtkPrinter *printer)
442 g_return_val_if_fail (GTK_IS_PRINTER (printer), NULL);
444 return printer->priv->name;
448 * gtk_printer_get_description:
449 * @printer: a #GtkPrinter
451 * Gets the description of the printer.
453 * Return value: the description of @printer
457 G_CONST_RETURN gchar *
458 gtk_printer_get_description (GtkPrinter *printer)
460 g_return_val_if_fail (GTK_IS_PRINTER (printer), NULL);
462 return printer->priv->description;
466 gtk_printer_set_description (GtkPrinter *printer,
467 const gchar *description)
469 GtkPrinterPrivate *priv;
471 g_return_val_if_fail (GTK_IS_PRINTER (printer), FALSE);
473 priv = printer->priv;
475 if (g_strcmp0 (priv->description, description) == 0)
478 g_free (priv->description);
479 priv->description = g_strdup (description);
485 * gtk_printer_get_state_message:
486 * @printer: a #GtkPrinter
488 * Returns the state message describing the current state
491 * Return value: the state message of @printer
495 G_CONST_RETURN gchar *
496 gtk_printer_get_state_message (GtkPrinter *printer)
498 g_return_val_if_fail (GTK_IS_PRINTER (printer), NULL);
500 return printer->priv->state_message;
504 gtk_printer_set_state_message (GtkPrinter *printer,
505 const gchar *message)
507 GtkPrinterPrivate *priv;
509 g_return_val_if_fail (GTK_IS_PRINTER (printer), FALSE);
511 priv = printer->priv;
513 if (g_strcmp0 (priv->state_message, message) == 0)
516 g_free (priv->state_message);
517 priv->state_message = g_strdup (message);
518 g_object_notify (G_OBJECT (printer), "state-message");
524 * gtk_printer_get_location:
525 * @printer: a #GtkPrinter
527 * Returns a description of the location of the printer.
529 * Return value: the location of @printer
533 G_CONST_RETURN gchar *
534 gtk_printer_get_location (GtkPrinter *printer)
536 g_return_val_if_fail (GTK_IS_PRINTER (printer), NULL);
538 return printer->priv->location;
542 gtk_printer_set_location (GtkPrinter *printer,
543 const gchar *location)
545 GtkPrinterPrivate *priv;
547 g_return_val_if_fail (GTK_IS_PRINTER (printer), FALSE);
549 priv = printer->priv;
551 if (g_strcmp0 (priv->location, location) == 0)
554 g_free (priv->location);
555 priv->location = g_strdup (location);
556 g_object_notify (G_OBJECT (printer), "location");
562 * gtk_printer_get_icon_name:
563 * @printer: a #GtkPrinter
565 * Gets the name of the icon to use for the printer.
567 * Return value: the icon name for @printer
571 G_CONST_RETURN gchar *
572 gtk_printer_get_icon_name (GtkPrinter *printer)
574 g_return_val_if_fail (GTK_IS_PRINTER (printer), NULL);
576 return printer->priv->icon_name;
580 gtk_printer_set_icon_name (GtkPrinter *printer,
583 GtkPrinterPrivate *priv;
585 g_return_if_fail (GTK_IS_PRINTER (printer));
587 priv = printer->priv;
589 g_free (priv->icon_name);
590 priv->icon_name = g_strdup (icon);
591 g_object_notify (G_OBJECT (printer), "icon-name");
595 * gtk_printer_get_job_count:
596 * @printer: a #GtkPrinter
598 * Gets the number of jobs currently queued on the printer.
600 * Return value: the number of jobs on @printer
605 gtk_printer_get_job_count (GtkPrinter *printer)
607 g_return_val_if_fail (GTK_IS_PRINTER (printer), 0);
609 return printer->priv->job_count;
613 gtk_printer_set_job_count (GtkPrinter *printer,
616 GtkPrinterPrivate *priv;
618 g_return_val_if_fail (GTK_IS_PRINTER (printer), FALSE);
620 priv = printer->priv;
622 if (priv->job_count == count)
625 priv->job_count = count;
627 g_object_notify (G_OBJECT (printer), "job-count");
633 * gtk_printer_has_details:
634 * @printer: a #GtkPrinter
636 * Returns whether the printer details are available.
638 * Return value: %TRUE if @printer details are available
643 gtk_printer_has_details (GtkPrinter *printer)
645 g_return_val_if_fail (GTK_IS_PRINTER (printer), FALSE);
647 return printer->priv->has_details;
651 gtk_printer_set_has_details (GtkPrinter *printer,
654 printer->priv->has_details = val;
658 * gtk_printer_is_active:
659 * @printer: a #GtkPrinter
661 * Returns whether the printer is currently active (i.e.
664 * Return value: %TRUE if @printer is active
669 gtk_printer_is_active (GtkPrinter *printer)
671 g_return_val_if_fail (GTK_IS_PRINTER (printer), TRUE);
673 return printer->priv->is_active;
677 gtk_printer_set_is_active (GtkPrinter *printer,
680 g_return_if_fail (GTK_IS_PRINTER (printer));
682 printer->priv->is_active = val;
686 * gtk_printer_is_paused:
687 * @printer: a #GtkPrinter
689 * Returns whether the printer is currently paused.
690 * A paused printer still accepts jobs, but it is not
693 * Return value: %TRUE if @printer is paused
698 gtk_printer_is_paused (GtkPrinter *printer)
700 g_return_val_if_fail (GTK_IS_PRINTER (printer), TRUE);
702 return printer->priv->is_paused;
706 gtk_printer_set_is_paused (GtkPrinter *printer,
709 GtkPrinterPrivate *priv;
711 g_return_val_if_fail (GTK_IS_PRINTER (printer), FALSE);
713 priv = printer->priv;
715 if (val == priv->is_paused)
718 priv->is_paused = val;
724 * gtk_printer_is_accepting_jobs:
725 * @printer: a #GtkPrinter
727 * Returns whether the printer is accepting jobs
729 * Return value: %TRUE if @printer is accepting jobs
734 gtk_printer_is_accepting_jobs (GtkPrinter *printer)
736 g_return_val_if_fail (GTK_IS_PRINTER (printer), TRUE);
738 return printer->priv->is_accepting_jobs;
742 gtk_printer_set_is_accepting_jobs (GtkPrinter *printer,
745 GtkPrinterPrivate *priv;
747 g_return_val_if_fail (GTK_IS_PRINTER (printer), FALSE);
749 priv = printer->priv;
751 if (val == priv->is_accepting_jobs)
754 priv->is_accepting_jobs = val;
760 * gtk_printer_is_virtual:
761 * @printer: a #GtkPrinter
763 * Returns whether the printer is virtual (i.e. does not
764 * represent actual printer hardware, but something like
767 * Return value: %TRUE if @printer is virtual
772 gtk_printer_is_virtual (GtkPrinter *printer)
774 g_return_val_if_fail (GTK_IS_PRINTER (printer), TRUE);
776 return printer->priv->is_virtual;
780 * gtk_printer_accepts_pdf:
781 * @printer: a #GtkPrinter
783 * Returns whether the printer accepts input in
786 * Return value: %TRUE if @printer accepts PDF
791 gtk_printer_accepts_pdf (GtkPrinter *printer)
793 g_return_val_if_fail (GTK_IS_PRINTER (printer), TRUE);
795 return printer->priv->accepts_pdf;
799 gtk_printer_set_accepts_pdf (GtkPrinter *printer,
802 g_return_if_fail (GTK_IS_PRINTER (printer));
804 printer->priv->accepts_pdf = val;
808 * gtk_printer_accepts_ps:
809 * @printer: a #GtkPrinter
811 * Returns whether the printer accepts input in
814 * Return value: %TRUE if @printer accepts PostScript
819 gtk_printer_accepts_ps (GtkPrinter *printer)
821 g_return_val_if_fail (GTK_IS_PRINTER (printer), TRUE);
823 return printer->priv->accepts_ps;
827 gtk_printer_set_accepts_ps (GtkPrinter *printer,
830 g_return_if_fail (GTK_IS_PRINTER (printer));
832 printer->priv->accepts_ps = val;
836 gtk_printer_is_new (GtkPrinter *printer)
838 g_return_val_if_fail (GTK_IS_PRINTER (printer), FALSE);
840 return printer->priv->is_new;
844 gtk_printer_set_is_new (GtkPrinter *printer,
847 g_return_if_fail (GTK_IS_PRINTER (printer));
849 printer->priv->is_new = val;
854 * gtk_printer_is_default:
855 * @printer: a #GtkPrinter
857 * Returns whether the printer is the default printer.
859 * Return value: %TRUE if @printer is the default
864 gtk_printer_is_default (GtkPrinter *printer)
866 g_return_val_if_fail (GTK_IS_PRINTER (printer), FALSE);
868 return printer->priv->is_default;
872 gtk_printer_set_is_default (GtkPrinter *printer,
875 g_return_if_fail (GTK_IS_PRINTER (printer));
877 printer->priv->is_default = val;
881 * gtk_printer_request_details:
882 * @printer: a #GtkPrinter
884 * Requests the printer details. When the details are available,
885 * the #GtkPrinter::details-acquired signal will be emitted on @printer.
890 gtk_printer_request_details (GtkPrinter *printer)
892 GtkPrintBackendClass *backend_class;
894 g_return_if_fail (GTK_IS_PRINTER (printer));
896 backend_class = GTK_PRINT_BACKEND_GET_CLASS (printer->priv->backend);
897 backend_class->printer_request_details (printer);
900 GtkPrinterOptionSet *
901 _gtk_printer_get_options (GtkPrinter *printer,
902 GtkPrintSettings *settings,
903 GtkPageSetup *page_setup,
904 GtkPrintCapabilities capabilities)
906 GtkPrintBackendClass *backend_class = GTK_PRINT_BACKEND_GET_CLASS (printer->priv->backend);
907 return backend_class->printer_get_options (printer, settings, page_setup, capabilities);
911 _gtk_printer_mark_conflicts (GtkPrinter *printer,
912 GtkPrinterOptionSet *options)
914 GtkPrintBackendClass *backend_class = GTK_PRINT_BACKEND_GET_CLASS (printer->priv->backend);
915 return backend_class->printer_mark_conflicts (printer, options);
919 _gtk_printer_get_settings_from_options (GtkPrinter *printer,
920 GtkPrinterOptionSet *options,
921 GtkPrintSettings *settings)
923 GtkPrintBackendClass *backend_class = GTK_PRINT_BACKEND_GET_CLASS (printer->priv->backend);
924 backend_class->printer_get_settings_from_options (printer, options, settings);
928 _gtk_printer_prepare_for_print (GtkPrinter *printer,
929 GtkPrintJob *print_job,
930 GtkPrintSettings *settings,
931 GtkPageSetup *page_setup)
933 GtkPrintBackendClass *backend_class = GTK_PRINT_BACKEND_GET_CLASS (printer->priv->backend);
934 backend_class->printer_prepare_for_print (printer, print_job, settings, page_setup);
938 _gtk_printer_create_cairo_surface (GtkPrinter *printer,
939 GtkPrintSettings *settings,
942 GIOChannel *cache_io)
944 GtkPrintBackendClass *backend_class = GTK_PRINT_BACKEND_GET_CLASS (printer->priv->backend);
946 return backend_class->printer_create_cairo_surface (printer, settings,
947 width, height, cache_io);
951 * gtk_printer_list_papers:
952 * @printer: a #GtkPrinter
954 * Lists all the paper sizes @printer supports.
955 * This will return and empty list unless the printer's details are
956 * available, see gtk_printer_has_details() and gtk_printer_request_details().
958 * Return value: (element-type GtkPageSetup) (transfer full): a newly allocated list of newly allocated #GtkPageSetup s.
963 gtk_printer_list_papers (GtkPrinter *printer)
965 GtkPrintBackendClass *backend_class;
967 g_return_val_if_fail (GTK_IS_PRINTER (printer), NULL);
969 backend_class = GTK_PRINT_BACKEND_GET_CLASS (printer->priv->backend);
970 return backend_class->printer_list_papers (printer);
974 * gtk_printer_get_default_page_size:
975 * @printer: a #GtkPrinter
977 * Returns default page size of @printer.
979 * Return value: a newly allocated #GtkPageSetup with default page size of the printer.
984 gtk_printer_get_default_page_size (GtkPrinter *printer)
986 GtkPrintBackendClass *backend_class;
988 g_return_val_if_fail (GTK_IS_PRINTER (printer), NULL);
990 backend_class = GTK_PRINT_BACKEND_GET_CLASS (printer->priv->backend);
991 return backend_class->printer_get_default_page_size (printer);
995 * gtk_printer_get_hard_margins:
996 * @printer: a #GtkPrinter
997 * @top: (out): a location to store the top margin in
998 * @bottom: (out): a location to store the bottom margin in
999 * @left: (out): a location to store the left margin in
1000 * @right: (out): a location to store the right margin in
1002 * Retrieve the hard margins of @printer, i.e. the margins that define
1003 * the area at the borders of the paper that the printer cannot print to.
1005 * Note: This will not succeed unless the printer's details are available,
1006 * see gtk_printer_has_details() and gtk_printer_request_details().
1008 * Return value: %TRUE iff the hard margins were retrieved
1013 gtk_printer_get_hard_margins (GtkPrinter *printer,
1019 GtkPrintBackendClass *backend_class = GTK_PRINT_BACKEND_GET_CLASS (printer->priv->backend);
1021 return backend_class->printer_get_hard_margins (printer, top, bottom, left, right);
1025 * gtk_printer_get_capabilities:
1026 * @printer: a #GtkPrinter
1028 * Returns the printer's capabilities.
1030 * This is useful when you're using #GtkPrintUnixDialog's manual-capabilities
1031 * setting and need to know which settings the printer can handle and which
1032 * you must handle yourself.
1034 * This will return 0 unless the printer's details are available, see
1035 * gtk_printer_has_details() and gtk_printer_request_details().
1037 * Return value: the printer's capabilities
1041 GtkPrintCapabilities
1042 gtk_printer_get_capabilities (GtkPrinter *printer)
1044 GtkPrintBackendClass *backend_class;
1046 g_return_val_if_fail (GTK_IS_PRINTER (printer), 0);
1048 backend_class = GTK_PRINT_BACKEND_GET_CLASS (printer->priv->backend);
1049 return backend_class->printer_get_capabilities (printer);
1053 * gtk_printer_compare:
1055 * @b: another #GtkPrinter
1057 * Compares two printers.
1059 * Return value: 0 if the printer match, a negative value if @a < @b,
1060 * or a positive value if @a > @b
1065 gtk_printer_compare (GtkPrinter *a,
1068 const char *name_a, *name_b;
1070 g_assert (GTK_IS_PRINTER (a) && GTK_IS_PRINTER (b));
1072 name_a = gtk_printer_get_name (a);
1073 name_b = gtk_printer_get_name (b);
1074 if (name_a == NULL && name_b == NULL)
1076 else if (name_a == NULL)
1078 else if (name_b == NULL)
1081 return g_ascii_strcasecmp (name_a, name_b);
1088 GtkPrinterFunc func;
1090 GDestroyNotify destroy;
1094 static void list_done_cb (GtkPrintBackend *backend,
1095 PrinterList *printer_list);
1098 stop_enumeration (PrinterList *printer_list)
1101 GtkPrintBackend *backend;
1103 for (list = printer_list->backends; list; list = next)
1106 backend = GTK_PRINT_BACKEND (list->data);
1107 list_done_cb (backend, printer_list);
1112 free_printer_list (PrinterList *printer_list)
1114 if (printer_list->destroy)
1115 printer_list->destroy (printer_list->data);
1117 if (printer_list->loop)
1119 g_main_loop_quit (printer_list->loop);
1120 g_main_loop_unref (printer_list->loop);
1123 g_free (printer_list);
1127 list_added_cb (GtkPrintBackend *backend,
1128 GtkPrinter *printer,
1129 PrinterList *printer_list)
1131 if (printer_list->func (printer, printer_list->data))
1133 stop_enumeration (printer_list);
1141 backend_status_changed (GObject *object,
1145 GtkPrintBackend *backend = GTK_PRINT_BACKEND (object);
1146 PrinterList *printer_list = data;
1147 GtkPrintBackendStatus status;
1149 g_object_get (backend, "status", &status, NULL);
1151 if (status == GTK_PRINT_BACKEND_STATUS_UNAVAILABLE)
1152 list_done_cb (backend, printer_list);
1156 list_done_cb (GtkPrintBackend *backend,
1157 PrinterList *printer_list)
1159 printer_list->backends = g_list_remove (printer_list->backends, backend);
1161 g_signal_handlers_disconnect_by_func (backend, list_added_cb, printer_list);
1162 g_signal_handlers_disconnect_by_func (backend, list_done_cb, printer_list);
1163 g_signal_handlers_disconnect_by_func (backend, backend_status_changed, printer_list);
1165 gtk_print_backend_destroy (backend);
1166 g_object_unref (backend);
1168 if (printer_list->backends == NULL)
1169 free_printer_list (printer_list);
1173 list_printers_init (PrinterList *printer_list,
1174 GtkPrintBackend *backend)
1177 GtkPrintBackendStatus status;
1179 list = gtk_print_backend_get_printer_list (backend);
1181 for (node = list; node != NULL; node = node->next)
1183 if (list_added_cb (backend, node->data, printer_list))
1192 g_object_get (backend, "status", &status, NULL);
1194 if (status == GTK_PRINT_BACKEND_STATUS_UNAVAILABLE ||
1195 gtk_print_backend_printer_list_is_done (backend))
1197 printer_list->backends = g_list_remove (printer_list->backends, backend);
1198 gtk_print_backend_destroy (backend);
1199 g_object_unref (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);