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"
34 #define GTK_PRINTER_GET_PRIVATE(o) \
35 (G_TYPE_INSTANCE_GET_PRIVATE ((o), GTK_TYPE_PRINTER, GtkPrinterPrivate))
37 static void gtk_printer_finalize (GObject *object);
39 struct _GtkPrinterPrivate
48 guint is_accepting_jobs : 1;
52 guint has_details : 1;
53 guint accepts_pdf : 1;
59 GtkPrintBackend *backend;
82 static guint signals[LAST_SIGNAL] = { 0 };
84 static void gtk_printer_set_property (GObject *object,
88 static void gtk_printer_get_property (GObject *object,
93 G_DEFINE_TYPE (GtkPrinter, gtk_printer, G_TYPE_OBJECT)
96 safe_strcmp (const char *a, const char *b)
104 return strcmp (a, b);
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 = GTK_PRINTER_GET_PRIVATE (printer);
246 priv->location = NULL;
247 priv->description = NULL;
248 priv->icon_name = NULL;
250 priv->is_active = TRUE;
251 priv->is_paused = FALSE;
252 priv->is_accepting_jobs = TRUE;
254 priv->has_details = FALSE;
255 priv->accepts_pdf = TRUE;
256 priv->accepts_ps = TRUE;
258 priv->state_message = NULL;
263 gtk_printer_finalize (GObject *object)
265 GtkPrinter *printer = GTK_PRINTER (object);
266 GtkPrinterPrivate *priv = printer->priv;
269 g_free (priv->location);
270 g_free (priv->description);
271 g_free (priv->state_message);
272 g_free (priv->icon_name);
275 g_object_unref (priv->backend);
277 G_OBJECT_CLASS (gtk_printer_parent_class)->finalize (object);
281 gtk_printer_set_property (GObject *object,
286 GtkPrinter *printer = GTK_PRINTER (object);
287 GtkPrinterPrivate *priv = printer->priv;
292 priv->name = g_value_dup_string (value);
296 priv->backend = GTK_PRINT_BACKEND (g_value_dup_object (value));
299 case PROP_IS_VIRTUAL:
300 priv->is_virtual = g_value_get_boolean (value);
303 case PROP_ACCEPTS_PDF:
304 priv->accepts_pdf = g_value_get_boolean (value);
307 case PROP_ACCEPTS_PS:
308 priv->accepts_ps = g_value_get_boolean (value);
312 G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
318 gtk_printer_get_property (GObject *object,
323 GtkPrinter *printer = GTK_PRINTER (object);
324 GtkPrinterPrivate *priv = printer->priv;
330 g_value_set_string (value, priv->name);
332 g_value_set_static_string (value, "");
335 g_value_set_object (value, priv->backend);
337 case PROP_STATE_MESSAGE:
338 if (priv->state_message)
339 g_value_set_string (value, priv->state_message);
341 g_value_set_static_string (value, "");
345 g_value_set_string (value, priv->location);
347 g_value_set_static_string (value, "");
351 g_value_set_string (value, priv->icon_name);
353 g_value_set_static_string (value, "");
356 g_value_set_int (value, priv->job_count);
358 case PROP_IS_VIRTUAL:
359 g_value_set_boolean (value, priv->is_virtual);
361 case PROP_ACCEPTS_PDF:
362 g_value_set_boolean (value, priv->accepts_pdf);
364 case PROP_ACCEPTS_PS:
365 g_value_set_boolean (value, priv->accepts_ps);
368 g_value_set_boolean (value, priv->is_paused);
370 case PROP_ACCEPTING_JOBS:
371 g_value_set_boolean (value, priv->is_accepting_jobs);
374 G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
381 * @name: the name of the printer
382 * @backend: a #GtkPrintBackend
383 * @virtual_: whether the printer is virtual
385 * Creates a new #GtkPrinter.
387 * Return value: a new #GtkPrinter
392 gtk_printer_new (const gchar *name,
393 GtkPrintBackend *backend,
398 result = g_object_new (GTK_TYPE_PRINTER,
401 "is-virtual", virtual_,
404 return (GtkPrinter *) result;
408 * gtk_printer_get_backend:
409 * @printer: a #GtkPrinter
411 * Returns the backend of the printer.
413 * Return value: the backend of @printer
418 gtk_printer_get_backend (GtkPrinter *printer)
420 g_return_val_if_fail (GTK_IS_PRINTER (printer), NULL);
422 return printer->priv->backend;
426 * gtk_printer_get_name:
427 * @printer: a #GtkPrinter
429 * Returns the name of the printer.
431 * Return value: the name of @printer
435 G_CONST_RETURN gchar *
436 gtk_printer_get_name (GtkPrinter *printer)
438 g_return_val_if_fail (GTK_IS_PRINTER (printer), NULL);
440 return printer->priv->name;
444 * gtk_printer_get_description:
445 * @printer: a #GtkPrinter
447 * Gets the description of the printer.
449 * Return value: the description of @printer
453 G_CONST_RETURN gchar *
454 gtk_printer_get_description (GtkPrinter *printer)
456 g_return_val_if_fail (GTK_IS_PRINTER (printer), NULL);
458 return printer->priv->description;
462 gtk_printer_set_description (GtkPrinter *printer,
463 const gchar *description)
465 GtkPrinterPrivate *priv;
467 g_return_val_if_fail (GTK_IS_PRINTER (printer), FALSE);
469 priv = printer->priv;
471 if (safe_strcmp (priv->description, description) == 0)
474 g_free (priv->description);
475 priv->description = g_strdup (description);
481 * gtk_printer_get_state_message:
482 * @printer: a #GtkPrinter
484 * Returns the state message describing the current state
487 * Return value: the state message of @printer
491 G_CONST_RETURN gchar *
492 gtk_printer_get_state_message (GtkPrinter *printer)
494 g_return_val_if_fail (GTK_IS_PRINTER (printer), NULL);
496 return printer->priv->state_message;
500 gtk_printer_set_state_message (GtkPrinter *printer,
501 const gchar *message)
503 GtkPrinterPrivate *priv;
505 g_return_val_if_fail (GTK_IS_PRINTER (printer), FALSE);
507 priv = printer->priv;
509 if (safe_strcmp (priv->state_message, message) == 0)
512 g_free (priv->state_message);
513 priv->state_message = g_strdup (message);
514 g_object_notify (G_OBJECT (printer), "state-message");
520 * gtk_printer_get_location:
521 * @printer: a #GtkPrinter
523 * Returns a description of the location of the printer.
525 * Return value: the location of @printer
529 G_CONST_RETURN gchar *
530 gtk_printer_get_location (GtkPrinter *printer)
532 g_return_val_if_fail (GTK_IS_PRINTER (printer), NULL);
534 return printer->priv->location;
538 gtk_printer_set_location (GtkPrinter *printer,
539 const gchar *location)
541 GtkPrinterPrivate *priv;
543 g_return_val_if_fail (GTK_IS_PRINTER (printer), FALSE);
545 priv = printer->priv;
547 if (safe_strcmp (priv->location, location) == 0)
550 g_free (priv->location);
551 priv->location = g_strdup (location);
552 g_object_notify (G_OBJECT (printer), "location");
558 * gtk_printer_get_icon_name:
559 * @printer: a #GtkPrinter
561 * Gets the name of the icon to use for the printer.
563 * Return value: the icon name for @printer
567 G_CONST_RETURN gchar *
568 gtk_printer_get_icon_name (GtkPrinter *printer)
570 g_return_val_if_fail (GTK_IS_PRINTER (printer), NULL);
572 return printer->priv->icon_name;
576 gtk_printer_set_icon_name (GtkPrinter *printer,
579 GtkPrinterPrivate *priv;
581 g_return_if_fail (GTK_IS_PRINTER (printer));
583 priv = printer->priv;
585 g_free (priv->icon_name);
586 priv->icon_name = g_strdup (icon);
587 g_object_notify (G_OBJECT (printer), "icon-name");
591 * gtk_printer_get_job_count:
592 * @printer: a #GtkPrinter
594 * Gets the number of jobs currently queued on the printer.
596 * Return value: the number of jobs on @printer
601 gtk_printer_get_job_count (GtkPrinter *printer)
603 g_return_val_if_fail (GTK_IS_PRINTER (printer), 0);
605 return printer->priv->job_count;
609 gtk_printer_set_job_count (GtkPrinter *printer,
612 GtkPrinterPrivate *priv;
614 g_return_val_if_fail (GTK_IS_PRINTER (printer), FALSE);
616 priv = printer->priv;
618 if (priv->job_count == count)
621 priv->job_count = count;
623 g_object_notify (G_OBJECT (printer), "job-count");
629 * gtk_printer_has_details:
630 * @printer: a #GtkPrinter
632 * Returns whether the printer details are available.
634 * Return value: %TRUE if @printer details are available
639 gtk_printer_has_details (GtkPrinter *printer)
641 g_return_val_if_fail (GTK_IS_PRINTER (printer), FALSE);
643 return printer->priv->has_details;
647 gtk_printer_set_has_details (GtkPrinter *printer,
650 printer->priv->has_details = val;
654 * gtk_printer_is_active:
655 * @printer: a #GtkPrinter
657 * Returns whether the printer is currently active (i.e.
660 * Return value: %TRUE if @printer is active
665 gtk_printer_is_active (GtkPrinter *printer)
667 g_return_val_if_fail (GTK_IS_PRINTER (printer), TRUE);
669 return printer->priv->is_active;
673 gtk_printer_set_is_active (GtkPrinter *printer,
676 g_return_if_fail (GTK_IS_PRINTER (printer));
678 printer->priv->is_active = val;
682 * gtk_printer_is_paused:
683 * @printer: a #GtkPrinter
685 * Returns whether the printer is currently paused.
686 * A paused printer still accepts jobs, but it is not
689 * Return value: %TRUE if @printer is paused
694 gtk_printer_is_paused (GtkPrinter *printer)
696 g_return_val_if_fail (GTK_IS_PRINTER (printer), TRUE);
698 return printer->priv->is_paused;
702 gtk_printer_set_is_paused (GtkPrinter *printer,
705 GtkPrinterPrivate *priv;
707 g_return_val_if_fail (GTK_IS_PRINTER (printer), FALSE);
709 priv = printer->priv;
711 if (val == priv->is_paused)
714 priv->is_paused = val;
720 * gtk_printer_is_accepting_jobs:
721 * @printer: a #GtkPrinter
723 * Returns whether the printer is accepting jobs
725 * Return value: %TRUE if @printer is accepting jobs
730 gtk_printer_is_accepting_jobs (GtkPrinter *printer)
732 g_return_val_if_fail (GTK_IS_PRINTER (printer), TRUE);
734 return printer->priv->is_accepting_jobs;
738 gtk_printer_set_is_accepting_jobs (GtkPrinter *printer,
741 GtkPrinterPrivate *priv;
743 g_return_val_if_fail (GTK_IS_PRINTER (printer), FALSE);
745 priv = printer->priv;
747 if (val == priv->is_accepting_jobs)
750 priv->is_accepting_jobs = val;
756 * gtk_printer_is_virtual:
757 * @printer: a #GtkPrinter
759 * Returns whether the printer is virtual (i.e. does not
760 * represent actual printer hardware, but something like
763 * Return value: %TRUE if @printer is virtual
768 gtk_printer_is_virtual (GtkPrinter *printer)
770 g_return_val_if_fail (GTK_IS_PRINTER (printer), TRUE);
772 return printer->priv->is_virtual;
776 * gtk_printer_accepts_pdf:
777 * @printer: a #GtkPrinter
779 * Returns whether the printer accepts input in
782 * Return value: %TRUE if @printer accepts PDF
787 gtk_printer_accepts_pdf (GtkPrinter *printer)
789 g_return_val_if_fail (GTK_IS_PRINTER (printer), TRUE);
791 return printer->priv->accepts_pdf;
795 * gtk_printer_accepts_ps:
796 * @printer: a #GtkPrinter
798 * Returns whether the printer accepts input in
801 * Return value: %TRUE if @printer accepts PostScript
806 gtk_printer_accepts_ps (GtkPrinter *printer)
808 g_return_val_if_fail (GTK_IS_PRINTER (printer), TRUE);
810 return printer->priv->accepts_ps;
814 gtk_printer_is_new (GtkPrinter *printer)
816 g_return_val_if_fail (GTK_IS_PRINTER (printer), FALSE);
818 return printer->priv->is_new;
822 gtk_printer_set_is_new (GtkPrinter *printer,
825 g_return_if_fail (GTK_IS_PRINTER (printer));
827 printer->priv->is_new = val;
832 * gtk_printer_is_default:
833 * @printer: a #GtkPrinter
835 * Returns whether the printer is the default printer.
837 * Return value: %TRUE if @printer is the default
842 gtk_printer_is_default (GtkPrinter *printer)
844 g_return_val_if_fail (GTK_IS_PRINTER (printer), FALSE);
846 return printer->priv->is_default;
850 gtk_printer_set_is_default (GtkPrinter *printer,
853 g_return_if_fail (GTK_IS_PRINTER (printer));
855 printer->priv->is_default = val;
859 * gtk_printer_request_details:
860 * @printer: a #GtkPrinter
862 * Requests the printer details. When the details are available,
863 * the #GtkPrinter::details-acquired signal will be emitted on @printer.
868 gtk_printer_request_details (GtkPrinter *printer)
870 GtkPrintBackendClass *backend_class;
872 g_return_if_fail (GTK_IS_PRINTER (printer));
874 backend_class = GTK_PRINT_BACKEND_GET_CLASS (printer->priv->backend);
875 backend_class->printer_request_details (printer);
878 GtkPrinterOptionSet *
879 _gtk_printer_get_options (GtkPrinter *printer,
880 GtkPrintSettings *settings,
881 GtkPageSetup *page_setup,
882 GtkPrintCapabilities capabilities)
884 GtkPrintBackendClass *backend_class = GTK_PRINT_BACKEND_GET_CLASS (printer->priv->backend);
885 return backend_class->printer_get_options (printer, settings, page_setup, capabilities);
889 _gtk_printer_mark_conflicts (GtkPrinter *printer,
890 GtkPrinterOptionSet *options)
892 GtkPrintBackendClass *backend_class = GTK_PRINT_BACKEND_GET_CLASS (printer->priv->backend);
893 return backend_class->printer_mark_conflicts (printer, options);
897 _gtk_printer_get_settings_from_options (GtkPrinter *printer,
898 GtkPrinterOptionSet *options,
899 GtkPrintSettings *settings)
901 GtkPrintBackendClass *backend_class = GTK_PRINT_BACKEND_GET_CLASS (printer->priv->backend);
902 backend_class->printer_get_settings_from_options (printer, options, settings);
906 _gtk_printer_prepare_for_print (GtkPrinter *printer,
907 GtkPrintJob *print_job,
908 GtkPrintSettings *settings,
909 GtkPageSetup *page_setup)
911 GtkPrintBackendClass *backend_class = GTK_PRINT_BACKEND_GET_CLASS (printer->priv->backend);
912 backend_class->printer_prepare_for_print (printer, print_job, settings, page_setup);
916 _gtk_printer_create_cairo_surface (GtkPrinter *printer,
917 GtkPrintSettings *settings,
920 GIOChannel *cache_io)
922 GtkPrintBackendClass *backend_class = GTK_PRINT_BACKEND_GET_CLASS (printer->priv->backend);
924 return backend_class->printer_create_cairo_surface (printer, settings,
925 width, height, cache_io);
929 * gtk_printer_list_papers:
930 * @printer: a #GtkPrinter
932 * Lists all the paper sizes @printer supports.
933 * This will return and empty list unless the printer's details are
934 * available, see gtk_printer_has_details() and gtk_printer_request_details().
936 * Return value: (element-type GtkPageSetup) (transfer full): a newly allocated list of newly allocated #GtkPageSetup s.
941 gtk_printer_list_papers (GtkPrinter *printer)
943 GtkPrintBackendClass *backend_class;
945 g_return_val_if_fail (GTK_IS_PRINTER (printer), NULL);
947 backend_class = GTK_PRINT_BACKEND_GET_CLASS (printer->priv->backend);
948 return backend_class->printer_list_papers (printer);
952 * gtk_printer_get_default_page_size:
953 * @printer: a #GtkPrinter
955 * Returns default page size of @printer.
957 * Return value: a newly allocated #GtkPageSetup with default page size of the printer.
962 gtk_printer_get_default_page_size (GtkPrinter *printer)
964 GtkPrintBackendClass *backend_class;
966 g_return_val_if_fail (GTK_IS_PRINTER (printer), NULL);
968 backend_class = GTK_PRINT_BACKEND_GET_CLASS (printer->priv->backend);
969 return backend_class->printer_get_default_page_size (printer);
973 * gtk_printer_get_hard_margins:
974 * @printer: a #GtkPrinter
975 * @top: a location to store the top margin in
976 * @bottom: a location to store the bottom margin in
977 * @left: a location to store the left margin in
978 * @right: a location to store the right margin in
980 * Retrieve the hard margins of @printer, i.e. the margins that define
981 * the area at the borders of the paper that the printer cannot print to.
983 * Note: This will not succeed unless the printer's details are available,
984 * see gtk_printer_has_details() and gtk_printer_request_details().
986 * Return value: %TRUE iff the hard margins were retrieved
991 gtk_printer_get_hard_margins (GtkPrinter *printer,
997 GtkPrintBackendClass *backend_class = GTK_PRINT_BACKEND_GET_CLASS (printer->priv->backend);
999 return backend_class->printer_get_hard_margins (printer, top, bottom, left, right);
1003 * gtk_printer_get_capabilities:
1004 * @printer: a #GtkPrinter
1006 * Returns the printer's capabilities.
1008 * This is useful when you're using #GtkPrintUnixDialog's manual-capabilities
1009 * setting and need to know which settings the printer can handle and which
1010 * you must handle yourself.
1012 * This will return 0 unless the printer's details are available, see
1013 * gtk_printer_has_details() and gtk_printer_request_details().
1015 * Return value: the printer's capabilities
1019 GtkPrintCapabilities
1020 gtk_printer_get_capabilities (GtkPrinter *printer)
1022 GtkPrintBackendClass *backend_class;
1024 g_return_val_if_fail (GTK_IS_PRINTER (printer), 0);
1026 backend_class = GTK_PRINT_BACKEND_GET_CLASS (printer->priv->backend);
1027 return backend_class->printer_get_capabilities (printer);
1031 * gtk_printer_compare:
1033 * @b: another #GtkPrinter
1035 * Compares two printers.
1037 * Return value: 0 if the printer match, a negative value if @a < @b,
1038 * or a positive value if @a > @b
1043 gtk_printer_compare (GtkPrinter *a,
1046 const char *name_a, *name_b;
1048 g_assert (GTK_IS_PRINTER (a) && GTK_IS_PRINTER (b));
1050 name_a = gtk_printer_get_name (a);
1051 name_b = gtk_printer_get_name (b);
1052 if (name_a == NULL && name_b == NULL)
1054 else if (name_a == NULL)
1056 else if (name_b == NULL)
1059 return g_ascii_strcasecmp (name_a, name_b);
1066 GtkPrinterFunc func;
1068 GDestroyNotify destroy;
1072 static void list_done_cb (GtkPrintBackend *backend,
1073 PrinterList *printer_list);
1076 stop_enumeration (PrinterList *printer_list)
1079 GtkPrintBackend *backend;
1081 for (list = printer_list->backends; list; list = next)
1084 backend = GTK_PRINT_BACKEND (list->data);
1085 list_done_cb (backend, printer_list);
1090 free_printer_list (PrinterList *printer_list)
1092 if (printer_list->destroy)
1093 printer_list->destroy (printer_list->data);
1095 if (printer_list->loop)
1097 g_main_loop_quit (printer_list->loop);
1098 g_main_loop_unref (printer_list->loop);
1101 g_free (printer_list);
1105 list_added_cb (GtkPrintBackend *backend,
1106 GtkPrinter *printer,
1107 PrinterList *printer_list)
1109 if (printer_list->func (printer, printer_list->data))
1111 stop_enumeration (printer_list);
1119 backend_status_changed (GObject *object,
1123 GtkPrintBackend *backend = GTK_PRINT_BACKEND (object);
1124 PrinterList *printer_list = data;
1125 GtkPrintBackendStatus status;
1127 g_object_get (backend, "status", &status, NULL);
1129 if (status == GTK_PRINT_BACKEND_STATUS_UNAVAILABLE)
1130 list_done_cb (backend, printer_list);
1134 list_done_cb (GtkPrintBackend *backend,
1135 PrinterList *printer_list)
1137 printer_list->backends = g_list_remove (printer_list->backends, backend);
1139 g_signal_handlers_disconnect_by_func (backend, list_added_cb, printer_list);
1140 g_signal_handlers_disconnect_by_func (backend, list_done_cb, printer_list);
1141 g_signal_handlers_disconnect_by_func (backend, backend_status_changed, printer_list);
1143 gtk_print_backend_destroy (backend);
1144 g_object_unref (backend);
1146 if (printer_list->backends == NULL)
1147 free_printer_list (printer_list);
1151 list_printers_init (PrinterList *printer_list,
1152 GtkPrintBackend *backend)
1155 GtkPrintBackendStatus status;
1157 list = gtk_print_backend_get_printer_list (backend);
1159 for (node = list; node != NULL; node = node->next)
1161 if (list_added_cb (backend, node->data, printer_list))
1170 g_object_get (backend, "status", &status, NULL);
1172 if (status == GTK_PRINT_BACKEND_STATUS_UNAVAILABLE ||
1173 gtk_print_backend_printer_list_is_done (backend))
1175 printer_list->backends = g_list_remove (printer_list->backends, backend);
1176 gtk_print_backend_destroy (backend);
1177 g_object_unref (backend);
1181 g_signal_connect (backend, "printer-added",
1182 (GCallback) list_added_cb,
1184 g_signal_connect (backend, "printer-list-done",
1185 (GCallback) list_done_cb,
1187 g_signal_connect (backend, "notify::status",
1188 (GCallback) backend_status_changed,
1196 * gtk_enumerate_printers:
1197 * @func: a function to call for each printer
1198 * @data: user data to pass to @func
1199 * @destroy: function to call if @data is no longer needed
1200 * @wait: if %TRUE, wait in a recursive mainloop until
1201 * all printers are enumerated; otherwise return early
1203 * Calls a function for all #GtkPrinter<!-- -->s.
1204 * If @func returns %TRUE, the enumeration is stopped.
1209 gtk_enumerate_printers (GtkPrinterFunc func,
1211 GDestroyNotify destroy,
1214 PrinterList *printer_list;
1216 GtkPrintBackend *backend;
1218 printer_list = g_new0 (PrinterList, 1);
1220 printer_list->func = func;
1221 printer_list->data = data;
1222 printer_list->destroy = destroy;
1224 if (g_module_supported ())
1225 printer_list->backends = gtk_print_backend_load_modules ();
1227 if (printer_list->backends == NULL)
1229 free_printer_list (printer_list);
1233 for (node = printer_list->backends; node != NULL; node = next)
1236 backend = GTK_PRINT_BACKEND (node->data);
1237 if (list_printers_init (printer_list, backend))
1241 if (wait && printer_list->backends)
1243 printer_list->loop = g_main_loop_new (NULL, FALSE);
1245 GDK_THREADS_LEAVE ();
1246 g_main_loop_run (printer_list->loop);
1247 GDK_THREADS_ENTER ();
1252 gtk_print_capabilities_get_type (void)
1254 static GType etype = 0;
1256 if (G_UNLIKELY (etype == 0))
1258 static const GFlagsValue values[] = {
1259 { GTK_PRINT_CAPABILITY_PAGE_SET, "GTK_PRINT_CAPABILITY_PAGE_SET", "page-set" },
1260 { GTK_PRINT_CAPABILITY_COPIES, "GTK_PRINT_CAPABILITY_COPIES", "copies" },
1261 { GTK_PRINT_CAPABILITY_COLLATE, "GTK_PRINT_CAPABILITY_COLLATE", "collate" },
1262 { GTK_PRINT_CAPABILITY_REVERSE, "GTK_PRINT_CAPABILITY_REVERSE", "reverse" },
1263 { GTK_PRINT_CAPABILITY_SCALE, "GTK_PRINT_CAPABILITY_SCALE", "scale" },
1264 { GTK_PRINT_CAPABILITY_GENERATE_PDF, "GTK_PRINT_CAPABILITY_GENERATE_PDF", "generate-pdf" },
1265 { GTK_PRINT_CAPABILITY_GENERATE_PS, "GTK_PRINT_CAPABILITY_GENERATE_PS", "generate-ps" },
1266 { GTK_PRINT_CAPABILITY_PREVIEW, "GTK_PRINT_CAPABILITY_PREVIEW", "preview" },
1267 { GTK_PRINT_CAPABILITY_NUMBER_UP, "GTK_PRINT_CAPABILITY_NUMBER_UP", "number-up"},
1268 { GTK_PRINT_CAPABILITY_NUMBER_UP_LAYOUT, "GTK_PRINT_CAPABILITY_NUMBER_UP_LAYOUT", "number-up-layout" },
1272 etype = g_flags_register_static (I_("GtkPrintCapabilities"), values);
1279 #define __GTK_PRINTER_C__
1280 #include "gtkaliasdef.c"