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
50 guint has_details : 1;
51 guint accepts_pdf : 1;
57 GtkPrintBackend *backend;
78 static guint signals[LAST_SIGNAL] = { 0 };
80 static void gtk_printer_set_property (GObject *object,
84 static void gtk_printer_get_property (GObject *object,
89 G_DEFINE_TYPE (GtkPrinter, gtk_printer, G_TYPE_OBJECT)
92 safe_strcmp (const char *a, const char *b)
100 return strcmp (a, b);
104 gtk_printer_class_init (GtkPrinterClass *class)
106 GObjectClass *object_class;
107 object_class = (GObjectClass *) class;
109 object_class->finalize = gtk_printer_finalize;
111 object_class->set_property = gtk_printer_set_property;
112 object_class->get_property = gtk_printer_get_property;
114 g_type_class_add_private (class, sizeof (GtkPrinterPrivate));
116 g_object_class_install_property (G_OBJECT_CLASS (class),
118 g_param_spec_string ("name",
120 P_("Name of the printer"),
122 GTK_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY));
123 g_object_class_install_property (G_OBJECT_CLASS (class),
125 g_param_spec_object ("backend",
127 P_("Backend for the printer"),
128 GTK_TYPE_PRINT_BACKEND,
129 GTK_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY));
130 g_object_class_install_property (G_OBJECT_CLASS (class),
132 g_param_spec_boolean ("is-virtual",
134 P_("FALSE if this represents a real hardware printer"),
136 GTK_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY));
137 g_object_class_install_property (G_OBJECT_CLASS (class),
139 g_param_spec_boolean ("accepts-pdf",
141 P_("TRUE if this printer can accept PDF"),
143 GTK_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY));
144 g_object_class_install_property (G_OBJECT_CLASS (class),
146 g_param_spec_boolean ("accepts-ps",
147 P_("Accepts PostScript"),
148 P_("TRUE if this printer can accept PostScript"),
150 GTK_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY));
151 g_object_class_install_property (G_OBJECT_CLASS (class),
153 g_param_spec_string ("state-message",
155 P_("String giving the current state of the printer"),
157 GTK_PARAM_READABLE));
158 g_object_class_install_property (G_OBJECT_CLASS (class),
160 g_param_spec_string ("location",
162 P_("The location of the printer"),
164 GTK_PARAM_READABLE));
165 g_object_class_install_property (G_OBJECT_CLASS (class),
167 g_param_spec_string ("icon-name",
169 P_("The icon name to use for the printer"),
171 GTK_PARAM_READABLE));
172 g_object_class_install_property (G_OBJECT_CLASS (class),
174 g_param_spec_int ("job-count",
176 P_("Number of jobs queued in the printer"),
180 GTK_PARAM_READABLE));
183 * GtkPrinter::details-acquired:
184 * @printer: the #GtkPrinter on which the signal is emitted
185 * @success: %TRUE if the details were successfully acquired
187 * Gets emitted in response to a request for detailed information
188 * about a printer from the print backend. The @success parameter
189 * indicates if the information was actually obtained.
193 signals[DETAILS_ACQUIRED] =
194 g_signal_new (I_("details-acquired"),
195 G_TYPE_FROM_CLASS (class),
197 G_STRUCT_OFFSET (GtkPrinterClass, details_acquired),
199 g_cclosure_marshal_VOID__BOOLEAN,
200 G_TYPE_NONE, 1, G_TYPE_BOOLEAN);
204 gtk_printer_init (GtkPrinter *printer)
206 GtkPrinterPrivate *priv;
208 priv = printer->priv = GTK_PRINTER_GET_PRIVATE (printer);
211 priv->location = NULL;
212 priv->description = NULL;
213 priv->icon_name = NULL;
215 priv->is_active = TRUE;
217 priv->has_details = FALSE;
218 priv->accepts_pdf = TRUE;
219 priv->accepts_ps = TRUE;
221 priv->state_message = NULL;
226 gtk_printer_finalize (GObject *object)
228 GtkPrinter *printer = GTK_PRINTER (object);
229 GtkPrinterPrivate *priv = printer->priv;
232 g_free (priv->location);
233 g_free (priv->description);
234 g_free (priv->state_message);
235 g_free (priv->icon_name);
238 g_object_unref (priv->backend);
240 G_OBJECT_CLASS (gtk_printer_parent_class)->finalize (object);
244 gtk_printer_set_property (GObject *object,
249 GtkPrinter *printer = GTK_PRINTER (object);
250 GtkPrinterPrivate *priv = printer->priv;
255 priv->name = g_value_dup_string (value);
259 priv->backend = GTK_PRINT_BACKEND (g_value_dup_object (value));
262 case PROP_IS_VIRTUAL:
263 priv->is_virtual = g_value_get_boolean (value);
266 case PROP_ACCEPTS_PDF:
267 priv->accepts_pdf = g_value_get_boolean (value);
270 case PROP_ACCEPTS_PS:
271 priv->accepts_ps = g_value_get_boolean (value);
275 G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
281 gtk_printer_get_property (GObject *object,
286 GtkPrinter *printer = GTK_PRINTER (object);
287 GtkPrinterPrivate *priv = printer->priv;
293 g_value_set_string (value, priv->name);
295 g_value_set_string (value, "");
298 g_value_set_object (value, priv->backend);
300 case PROP_STATE_MESSAGE:
301 if (priv->state_message)
302 g_value_set_string (value, priv->state_message);
304 g_value_set_string (value, "");
308 g_value_set_string (value, priv->location);
310 g_value_set_string (value, "");
314 g_value_set_string (value, priv->icon_name);
316 g_value_set_string (value, "");
319 g_value_set_int (value, priv->job_count);
321 case PROP_IS_VIRTUAL:
322 g_value_set_boolean (value, priv->is_virtual);
324 case PROP_ACCEPTS_PDF:
325 g_value_set_boolean (value, priv->accepts_pdf);
327 case PROP_ACCEPTS_PS:
328 g_value_set_boolean (value, priv->accepts_ps);
331 G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
338 * @name: the name of the printer
339 * @backend: a #GtkPrintBackend
340 * @virtual_: whether the printer is virtual
342 * Creates a new #GtkPrinter.
344 * Return value: a new #GtkPrinter
349 gtk_printer_new (const gchar *name,
350 GtkPrintBackend *backend,
355 result = g_object_new (GTK_TYPE_PRINTER,
358 "is-virtual", virtual_,
361 return (GtkPrinter *) result;
365 * gtk_printer_get_backend:
366 * @printer: a #GtkPrinter
368 * Returns the backend of the printer.
370 * Return value: the backend of @printer
375 gtk_printer_get_backend (GtkPrinter *printer)
377 g_return_val_if_fail (GTK_IS_PRINTER (printer), NULL);
379 return printer->priv->backend;
383 * gtk_printer_get_name:
384 * @printer: a #GtkPrinter
386 * Returns the name of the printer.
388 * Return value: the name of @printer
392 G_CONST_RETURN gchar *
393 gtk_printer_get_name (GtkPrinter *printer)
395 g_return_val_if_fail (GTK_IS_PRINTER (printer), NULL);
397 return printer->priv->name;
401 * gtk_printer_get_description:
402 * @printer: a #GtkPrinter
404 * Gets the description of the printer.
406 * Return value: the description of @printer
410 G_CONST_RETURN gchar *
411 gtk_printer_get_description (GtkPrinter *printer)
413 g_return_val_if_fail (GTK_IS_PRINTER (printer), NULL);
415 return printer->priv->description;
419 gtk_printer_set_description (GtkPrinter *printer,
420 const gchar *description)
422 GtkPrinterPrivate *priv;
424 g_return_val_if_fail (GTK_IS_PRINTER (printer), FALSE);
426 priv = printer->priv;
428 if (safe_strcmp (priv->description, description) == 0)
431 g_free (priv->description);
432 priv->description = g_strdup (description);
438 * gtk_printer_get_state_message:
439 * @printer: a #GtkPrinter
441 * Returns the state message describing the current state
444 * Return value: the state message of @printer
448 G_CONST_RETURN gchar *
449 gtk_printer_get_state_message (GtkPrinter *printer)
451 g_return_val_if_fail (GTK_IS_PRINTER (printer), NULL);
453 return printer->priv->state_message;
457 gtk_printer_set_state_message (GtkPrinter *printer,
458 const gchar *message)
460 GtkPrinterPrivate *priv;
462 g_return_val_if_fail (GTK_IS_PRINTER (printer), FALSE);
464 priv = printer->priv;
466 if (safe_strcmp (priv->state_message, message) == 0)
469 g_free (priv->state_message);
470 priv->state_message = g_strdup (message);
471 g_object_notify (G_OBJECT (printer), "state-message");
477 * gtk_printer_get_location:
478 * @printer: a #GtkPrinter
480 * Returns a description of the location of the printer.
482 * Return value: the location of @printer
486 G_CONST_RETURN gchar *
487 gtk_printer_get_location (GtkPrinter *printer)
489 g_return_val_if_fail (GTK_IS_PRINTER (printer), NULL);
491 return printer->priv->location;
495 gtk_printer_set_location (GtkPrinter *printer,
496 const gchar *location)
498 GtkPrinterPrivate *priv;
500 g_return_val_if_fail (GTK_IS_PRINTER (printer), FALSE);
502 priv = printer->priv;
504 if (safe_strcmp (priv->location, location) == 0)
507 g_free (priv->location);
508 priv->location = g_strdup (location);
509 g_object_notify (G_OBJECT (printer), "location");
515 * gtk_printer_get_icon_name:
516 * @printer: a #GtkPrinter
518 * Gets the name of the icon to use for the printer.
520 * Return value: the icon name for @printer
524 G_CONST_RETURN gchar *
525 gtk_printer_get_icon_name (GtkPrinter *printer)
527 g_return_val_if_fail (GTK_IS_PRINTER (printer), NULL);
529 return printer->priv->icon_name;
533 gtk_printer_set_icon_name (GtkPrinter *printer,
536 GtkPrinterPrivate *priv;
538 g_return_if_fail (GTK_IS_PRINTER (printer));
540 priv = printer->priv;
542 g_free (priv->icon_name);
543 priv->icon_name = g_strdup (icon);
544 g_object_notify (G_OBJECT (printer), "icon-name");
548 * gtk_printer_get_job_count:
549 * @printer: a #GtkPrinter
551 * Gets the number of jobs currently queued on the printer.
553 * Return value: the number of jobs on @printer
558 gtk_printer_get_job_count (GtkPrinter *printer)
560 g_return_val_if_fail (GTK_IS_PRINTER (printer), 0);
562 return printer->priv->job_count;
566 gtk_printer_set_job_count (GtkPrinter *printer,
569 GtkPrinterPrivate *priv;
571 g_return_val_if_fail (GTK_IS_PRINTER (printer), FALSE);
573 priv = printer->priv;
575 if (priv->job_count == count)
578 priv->job_count = count;
580 g_object_notify (G_OBJECT (printer), "job-count");
586 _gtk_printer_has_details (GtkPrinter *printer)
588 return printer->priv->has_details;
592 gtk_printer_set_has_details (GtkPrinter *printer,
595 printer->priv->has_details = val;
599 * gtk_printer_is_active:
600 * @printer: a #GtkPrinter
602 * Returns whether the printer is currently active (i.e.
605 * Return value: %TRUE if @printer is active
610 gtk_printer_is_active (GtkPrinter *printer)
612 g_return_val_if_fail (GTK_IS_PRINTER (printer), TRUE);
614 return printer->priv->is_active;
618 gtk_printer_set_is_active (GtkPrinter *printer,
621 g_return_if_fail (GTK_IS_PRINTER (printer));
623 printer->priv->is_active = val;
628 * gtk_printer_is_virtual:
629 * @printer: a #GtkPrinter
631 * Returns whether the printer is virtual (i.e. does not
632 * represent actual printer hardware, but something like
635 * Return value: %TRUE if @printer is virtual
640 gtk_printer_is_virtual (GtkPrinter *printer)
642 g_return_val_if_fail (GTK_IS_PRINTER (printer), TRUE);
644 return printer->priv->is_virtual;
648 gtk_printer_accepts_pdf (GtkPrinter *printer)
650 g_return_val_if_fail (GTK_IS_PRINTER (printer), TRUE);
652 return printer->priv->accepts_pdf;
656 gtk_printer_accepts_ps (GtkPrinter *printer)
658 g_return_val_if_fail (GTK_IS_PRINTER (printer), TRUE);
660 return printer->priv->accepts_ps;
664 gtk_printer_is_new (GtkPrinter *printer)
666 g_return_val_if_fail (GTK_IS_PRINTER (printer), FALSE);
668 return printer->priv->is_new;
672 gtk_printer_set_is_new (GtkPrinter *printer,
675 g_return_if_fail (GTK_IS_PRINTER (printer));
677 printer->priv->is_new = val;
682 * gtk_printer_is_default:
683 * @printer: a #GtkPrinter
685 * Returns whether the printer is the default printer.
687 * Return value: %TRUE if @printer is the default
692 gtk_printer_is_default (GtkPrinter *printer)
694 g_return_val_if_fail (GTK_IS_PRINTER (printer), FALSE);
696 return printer->priv->is_default;
700 gtk_printer_set_is_default (GtkPrinter *printer,
703 g_return_if_fail (GTK_IS_PRINTER (printer));
705 printer->priv->is_default = TRUE;
709 _gtk_printer_request_details (GtkPrinter *printer)
711 GtkPrintBackendClass *backend_class = GTK_PRINT_BACKEND_GET_CLASS (printer->priv->backend);
712 backend_class->printer_request_details (printer);
715 GtkPrinterOptionSet *
716 _gtk_printer_get_options (GtkPrinter *printer,
717 GtkPrintSettings *settings,
718 GtkPageSetup *page_setup,
719 GtkPrintCapabilities capabilities)
721 GtkPrintBackendClass *backend_class = GTK_PRINT_BACKEND_GET_CLASS (printer->priv->backend);
722 return backend_class->printer_get_options (printer, settings, page_setup, capabilities);
726 _gtk_printer_mark_conflicts (GtkPrinter *printer,
727 GtkPrinterOptionSet *options)
729 GtkPrintBackendClass *backend_class = GTK_PRINT_BACKEND_GET_CLASS (printer->priv->backend);
730 return backend_class->printer_mark_conflicts (printer, options);
734 _gtk_printer_get_settings_from_options (GtkPrinter *printer,
735 GtkPrinterOptionSet *options,
736 GtkPrintSettings *settings)
738 GtkPrintBackendClass *backend_class = GTK_PRINT_BACKEND_GET_CLASS (printer->priv->backend);
739 backend_class->printer_get_settings_from_options (printer, options, settings);
743 _gtk_printer_prepare_for_print (GtkPrinter *printer,
744 GtkPrintJob *print_job,
745 GtkPrintSettings *settings,
746 GtkPageSetup *page_setup)
748 GtkPrintBackendClass *backend_class = GTK_PRINT_BACKEND_GET_CLASS (printer->priv->backend);
749 backend_class->printer_prepare_for_print (printer, print_job, settings, page_setup);
753 _gtk_printer_create_cairo_surface (GtkPrinter *printer,
754 GtkPrintSettings *settings,
759 GtkPrintBackendClass *backend_class = GTK_PRINT_BACKEND_GET_CLASS (printer->priv->backend);
761 return backend_class->printer_create_cairo_surface (printer, settings,
762 width, height, cache_fd);
766 _gtk_printer_list_papers (GtkPrinter *printer)
768 GtkPrintBackendClass *backend_class = GTK_PRINT_BACKEND_GET_CLASS (printer->priv->backend);
770 return backend_class->printer_list_papers (printer);
774 _gtk_printer_get_hard_margins (GtkPrinter *printer,
780 GtkPrintBackendClass *backend_class = GTK_PRINT_BACKEND_GET_CLASS (printer->priv->backend);
782 backend_class->printer_get_hard_margins (printer, top, bottom, left, right);
786 _gtk_printer_get_capabilities (GtkPrinter *printer)
788 GtkPrintBackendClass *backend_class = GTK_PRINT_BACKEND_GET_CLASS (printer->priv->backend);
790 return backend_class->printer_get_capabilities (printer);
794 gtk_printer_compare (GtkPrinter *a, GtkPrinter *b)
796 const char *name_a, *name_b;
798 g_assert (GTK_IS_PRINTER (a) && GTK_IS_PRINTER (b));
800 name_a = gtk_printer_get_name (a);
801 name_b = gtk_printer_get_name (b);
802 if (name_a == NULL && name_b == NULL)
804 else if (name_a == NULL)
806 else if (name_b == NULL)
809 return g_ascii_strcasecmp (name_a, name_b);
818 GDestroyNotify destroy;
822 static void list_done_cb (GtkPrintBackend *backend,
823 PrinterList *printer_list);
826 stop_enumeration (PrinterList *printer_list)
829 GtkPrintBackend *backend;
831 for (list = printer_list->backends; list; list = next)
834 backend = GTK_PRINT_BACKEND (list->data);
835 list_done_cb (backend, printer_list);
838 if (printer_list->destroy)
839 printer_list->destroy (printer_list->data);
841 if (printer_list->loop)
843 g_main_loop_quit (printer_list->loop);
845 g_main_loop_unref (printer_list->loop);
848 g_free (printer_list);
852 list_added_cb (GtkPrintBackend *backend,
854 PrinterList *printer_list)
856 if (printer_list->func (printer, printer_list->data))
857 stop_enumeration (printer_list);
861 list_done_cb (GtkPrintBackend *backend,
862 PrinterList *printer_list)
864 printer_list->backends = g_list_remove (printer_list->backends, backend);
866 g_signal_handlers_disconnect_by_func (backend, list_added_cb, printer_list);
867 g_signal_handlers_disconnect_by_func (backend, list_done_cb, printer_list);
869 gtk_print_backend_destroy (backend);
870 g_object_unref (backend);
872 if (printer_list->backends == NULL)
873 stop_enumeration (printer_list);
877 list_printers_init (PrinterList *printer_list,
878 GtkPrintBackend *backend)
883 list = gtk_print_backend_get_printer_list (backend);
885 for (node = list; node != NULL; node = node->next)
886 list_added_cb (backend, node->data, printer_list);
890 if (gtk_print_backend_printer_list_is_done (backend))
892 printer_list->backends = g_list_remove (printer_list->backends, backend);
893 gtk_print_backend_destroy (backend);
894 g_object_unref (backend);
898 g_signal_connect (backend, "printer-added",
899 (GCallback) list_added_cb,
901 g_signal_connect (backend, "printer-list-done",
902 (GCallback) list_done_cb,
909 * gtk_enumerate_printers:
910 * @func: a function to call for each printer
911 * @data: user data to pass to @func
912 * @destroy: function to call if @data is no longer needed
913 * @wait: if %TRUE, wait in a recursive mainloop until
914 * all printers are enumerated; otherwise return early
916 * Calls a function for all #GtkPrinter<!-- -->s. If @func
917 * returns %TRUE, the enumeration is stopped.
922 gtk_enumerate_printers (GtkPrinterFunc func,
924 GDestroyNotify destroy,
927 PrinterList *printer_list;
928 GList *printers, *node, *next;
929 GtkPrintBackend *backend;
931 printer_list = g_new0 (PrinterList, 1);
933 printer_list->func = func;
934 printer_list->data = data;
935 printer_list->destroy = destroy;
937 if (g_module_supported ())
938 printer_list->backends = gtk_print_backend_load_modules ();
940 for (node = printer_list->backends; node != NULL; node = next)
943 backend = GTK_PRINT_BACKEND (node->data);
944 list_printers_init (printer_list, backend);
947 if (wait && printer_list->backends)
949 printer_list->loop = g_main_loop_new (NULL, FALSE);
951 GDK_THREADS_LEAVE ();
952 g_main_loop_run (printer_list->loop);
953 GDK_THREADS_ENTER ();
958 #define __GTK_PRINTER_C__
959 #include "gtkaliasdef.c"