X-Git-Url: http://pileus.org/git/?a=blobdiff_plain;f=gtk%2Fgtkprinter.c;h=fac0136fe5b6bb3433cbdb59f6eb45baa66c903d;hb=1074aa0c49f647ed4b2a969618051c59da5aad01;hp=b78f0b1ee130bb91982b0d656d144e9cadf9c1c0;hpb=061f252873596d738452923ea99e1e8419347da4;p=~andy%2Fgtk diff --git a/gtk/gtkprinter.c b/gtk/gtkprinter.c index b78f0b1ee..fac0136fe 100644 --- a/gtk/gtkprinter.c +++ b/gtk/gtkprinter.c @@ -12,9 +12,7 @@ * Lesser General Public License for more details. * * You should have received a copy of the GNU Lesser General Public - * License along with this library; if not, write to the - * Free Software Foundation, Inc., 59 Temple Place - Suite 330, - * Boston, MA 02111-1307, USA. + * License along with this library. If not, see . */ #include "config.h" @@ -29,10 +27,24 @@ #include "gtkprinter-private.h" #include "gtkprintbackend.h" #include "gtkprintjob.h" -#include "gtkalias.h" -#define GTK_PRINTER_GET_PRIVATE(o) \ - (G_TYPE_INSTANCE_GET_PRIVATE ((o), GTK_TYPE_PRINTER, GtkPrinterPrivate)) +/** + * SECTION:gtkprinter + * @Short_description: Represents a printer + * @Title: GtkPrinter + * + * A #GtkPrinter object represents a printer. You only need to + * deal directly with printers if you use the non-portable + * #GtkPrintUnixDialog API. + * + * A #GtkPrinter allows to get status information about the printer, + * such as its description, its location, the number of queued jobs, + * etc. Most importantly, a #GtkPrinter object can be used to create + * a #GtkPrintJob object, which lets you print to the printer. + * + * Printing support was added in GTK+ 2.10. + */ + static void gtk_printer_finalize (GObject *object); @@ -43,16 +55,19 @@ struct _GtkPrinterPrivate gchar *description; gchar *icon_name; - guint is_active: 1; - guint is_new: 1; - guint is_virtual : 1; - guint is_default : 1; - guint has_details: 1; + guint is_active : 1; + guint is_paused : 1; + guint is_accepting_jobs : 1; + guint is_new : 1; + guint is_virtual : 1; + guint is_default : 1; + guint has_details : 1; + guint accepts_pdf : 1; + guint accepts_ps : 1; gchar *state_message; gint job_count; - /* Not ref:ed, backend owns printer. */ GtkPrintBackend *backend; }; @@ -69,7 +84,11 @@ enum { PROP_STATE_MESSAGE, PROP_LOCATION, PROP_ICON_NAME, - PROP_JOB_COUNT + PROP_JOB_COUNT, + PROP_ACCEPTS_PDF, + PROP_ACCEPTS_PS, + PROP_PAUSED, + PROP_ACCEPTING_JOBS }; static guint signals[LAST_SIGNAL] = { 0 }; @@ -83,19 +102,7 @@ static void gtk_printer_get_property (GObject *object, GValue *value, GParamSpec *pspec); -G_DEFINE_TYPE (GtkPrinter, gtk_printer, G_TYPE_OBJECT); - -static int -safe_strcmp (const char *a, const char *b) -{ - if (a == b) - return 0; - if (a == NULL) - return -1; - if (b == NULL) - return 1; - return strcmp (a, b); -} +G_DEFINE_TYPE (GtkPrinter, gtk_printer, G_TYPE_OBJECT) static void gtk_printer_class_init (GtkPrinterClass *class) @@ -115,7 +122,7 @@ gtk_printer_class_init (GtkPrinterClass *class) g_param_spec_string ("name", P_("Name"), P_("Name of the printer"), - NULL, + "", GTK_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY)); g_object_class_install_property (G_OBJECT_CLASS (class), PROP_BACKEND, @@ -131,26 +138,40 @@ gtk_printer_class_init (GtkPrinterClass *class) P_("FALSE if this represents a real hardware printer"), FALSE, GTK_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY)); + g_object_class_install_property (G_OBJECT_CLASS (class), + PROP_ACCEPTS_PDF, + g_param_spec_boolean ("accepts-pdf", + P_("Accepts PDF"), + P_("TRUE if this printer can accept PDF"), + FALSE, + GTK_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY)); + g_object_class_install_property (G_OBJECT_CLASS (class), + PROP_ACCEPTS_PS, + g_param_spec_boolean ("accepts-ps", + P_("Accepts PostScript"), + P_("TRUE if this printer can accept PostScript"), + TRUE, + GTK_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY)); g_object_class_install_property (G_OBJECT_CLASS (class), PROP_STATE_MESSAGE, g_param_spec_string ("state-message", P_("State Message"), P_("String giving the current state of the printer"), - NULL, + "", GTK_PARAM_READABLE)); g_object_class_install_property (G_OBJECT_CLASS (class), PROP_LOCATION, g_param_spec_string ("location", P_("Location"), P_("The location of the printer"), - NULL, + "", GTK_PARAM_READABLE)); g_object_class_install_property (G_OBJECT_CLASS (class), PROP_ICON_NAME, g_param_spec_string ("icon-name", P_("Icon Name"), P_("The icon name to use for the printer"), - NULL, + "", GTK_PARAM_READABLE)); g_object_class_install_property (G_OBJECT_CLASS (class), PROP_JOB_COUNT, @@ -162,6 +183,37 @@ gtk_printer_class_init (GtkPrinterClass *class) 0, GTK_PARAM_READABLE)); + /** + * GtkPrinter:paused: + * + * This property is %TRUE if this printer is paused. + * A paused printer still accepts jobs, but it does + * not print them. + * + * Since: 2.14 + */ + g_object_class_install_property (G_OBJECT_CLASS (class), + PROP_PAUSED, + g_param_spec_boolean ("paused", + P_("Paused Printer"), + P_("TRUE if this printer is paused"), + FALSE, + GTK_PARAM_READABLE)); + /** + * GtkPrinter:accepting-jobs: + * + * This property is %TRUE if the printer is accepting jobs. + * + * Since: 2.14 + */ + g_object_class_install_property (G_OBJECT_CLASS (class), + PROP_ACCEPTING_JOBS, + g_param_spec_boolean ("accepting-jobs", + P_("Accepting Jobs"), + P_("TRUE if this printer is accepting new jobs"), + TRUE, + GTK_PARAM_READABLE)); + /** * GtkPrinter::details-acquired: * @printer: the #GtkPrinter on which the signal is emitted @@ -174,13 +226,13 @@ gtk_printer_class_init (GtkPrinterClass *class) * Since: 2.10 */ signals[DETAILS_ACQUIRED] = - g_signal_new ("details-acquired", - G_TYPE_FROM_CLASS (class), - G_SIGNAL_RUN_LAST, - G_STRUCT_OFFSET (GtkPrinterClass, details_acquired), - NULL, NULL, - g_cclosure_marshal_VOID__BOOLEAN, - G_TYPE_NONE, 1, G_TYPE_BOOLEAN); + g_signal_new (I_("details-acquired"), + G_TYPE_FROM_CLASS (class), + G_SIGNAL_RUN_LAST, + G_STRUCT_OFFSET (GtkPrinterClass, details_acquired), + NULL, NULL, + g_cclosure_marshal_VOID__BOOLEAN, + G_TYPE_NONE, 1, G_TYPE_BOOLEAN); } static void @@ -188,7 +240,9 @@ gtk_printer_init (GtkPrinter *printer) { GtkPrinterPrivate *priv; - priv = printer->priv = GTK_PRINTER_GET_PRIVATE (printer); + priv = printer->priv = G_TYPE_INSTANCE_GET_PRIVATE (printer, + GTK_TYPE_PRINTER, + GtkPrinterPrivate); priv->name = NULL; priv->location = NULL; @@ -196,8 +250,12 @@ gtk_printer_init (GtkPrinter *printer) priv->icon_name = NULL; priv->is_active = TRUE; + priv->is_paused = FALSE; + priv->is_accepting_jobs = TRUE; priv->is_new = TRUE; priv->has_details = FALSE; + priv->accepts_pdf = FALSE; + priv->accepts_ps = TRUE; priv->state_message = NULL; priv->job_count = 0; @@ -215,6 +273,9 @@ gtk_printer_finalize (GObject *object) g_free (priv->state_message); g_free (priv->icon_name); + if (priv->backend) + g_object_unref (priv->backend); + G_OBJECT_CLASS (gtk_printer_parent_class)->finalize (object); } @@ -234,13 +295,21 @@ gtk_printer_set_property (GObject *object, break; case PROP_BACKEND: - priv->backend = GTK_PRINT_BACKEND (g_value_get_object (value)); + priv->backend = GTK_PRINT_BACKEND (g_value_dup_object (value)); break; case PROP_IS_VIRTUAL: priv->is_virtual = g_value_get_boolean (value); break; + case PROP_ACCEPTS_PDF: + priv->accepts_pdf = g_value_get_boolean (value); + break; + + case PROP_ACCEPTS_PS: + priv->accepts_ps = g_value_get_boolean (value); + break; + default: G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); break; @@ -262,7 +331,7 @@ gtk_printer_get_property (GObject *object, if (priv->name) g_value_set_string (value, priv->name); else - g_value_set_string (value, ""); + g_value_set_static_string (value, ""); break; case PROP_BACKEND: g_value_set_object (value, priv->backend); @@ -271,23 +340,38 @@ gtk_printer_get_property (GObject *object, if (priv->state_message) g_value_set_string (value, priv->state_message); else - g_value_set_string (value, ""); + g_value_set_static_string (value, ""); break; case PROP_LOCATION: if (priv->location) g_value_set_string (value, priv->location); else - g_value_set_string (value, ""); + g_value_set_static_string (value, ""); break; case PROP_ICON_NAME: if (priv->icon_name) g_value_set_string (value, priv->icon_name); else - g_value_set_string (value, ""); + g_value_set_static_string (value, ""); break; case PROP_JOB_COUNT: g_value_set_int (value, priv->job_count); break; + case PROP_IS_VIRTUAL: + g_value_set_boolean (value, priv->is_virtual); + break; + case PROP_ACCEPTS_PDF: + g_value_set_boolean (value, priv->accepts_pdf); + break; + case PROP_ACCEPTS_PS: + g_value_set_boolean (value, priv->accepts_ps); + break; + case PROP_PAUSED: + g_value_set_boolean (value, priv->is_paused); + break; + case PROP_ACCEPTING_JOBS: + g_value_set_boolean (value, priv->is_accepting_jobs); + break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); break; @@ -298,7 +382,7 @@ gtk_printer_get_property (GObject *object, * gtk_printer_new: * @name: the name of the printer * @backend: a #GtkPrintBackend - * @virtual: whether the printer is virtual + * @virtual_: whether the printer is virtual * * Creates a new #GtkPrinter. * @@ -309,14 +393,14 @@ gtk_printer_get_property (GObject *object, GtkPrinter * gtk_printer_new (const gchar *name, GtkPrintBackend *backend, - gboolean virtual) + gboolean virtual_) { GObject *result; result = g_object_new (GTK_TYPE_PRINTER, "name", name, "backend", backend, - "is-virtual", virtual, + "is-virtual", virtual_, NULL); return (GtkPrinter *) result; @@ -328,7 +412,7 @@ gtk_printer_new (const gchar *name, * * Returns the backend of the printer. * - * Return value: the backend of @printer + * Return value: (transfer none): the backend of @printer * * Since: 2.10 */ @@ -340,16 +424,6 @@ gtk_printer_get_backend (GtkPrinter *printer) return printer->priv->backend; } -void -gtk_printer_set_backend (GtkPrinter *printer, - GtkPrintBackend *backend) -{ - g_return_if_fail (GTK_IS_PRINTER (printer)); - g_return_if_fail (GTK_IS_PRINT_BACKEND (backend)); - - printer->priv->backend = backend; -} - /** * gtk_printer_get_name: * @printer: a #GtkPrinter @@ -360,7 +434,7 @@ gtk_printer_set_backend (GtkPrinter *printer, * * Since: 2.10 */ -G_CONST_RETURN gchar * +const gchar * gtk_printer_get_name (GtkPrinter *printer) { g_return_val_if_fail (GTK_IS_PRINTER (printer), NULL); @@ -378,7 +452,7 @@ gtk_printer_get_name (GtkPrinter *printer) * * Since: 2.10 */ -G_CONST_RETURN gchar * +const gchar * gtk_printer_get_description (GtkPrinter *printer) { g_return_val_if_fail (GTK_IS_PRINTER (printer), NULL); @@ -396,7 +470,7 @@ gtk_printer_set_description (GtkPrinter *printer, priv = printer->priv; - if (safe_strcmp (priv->description, description) == 0) + if (g_strcmp0 (priv->description, description) == 0) return FALSE; g_free (priv->description); @@ -416,7 +490,7 @@ gtk_printer_set_description (GtkPrinter *printer, * * Since: 2.10 */ -G_CONST_RETURN gchar * +const gchar * gtk_printer_get_state_message (GtkPrinter *printer) { g_return_val_if_fail (GTK_IS_PRINTER (printer), NULL); @@ -434,7 +508,7 @@ gtk_printer_set_state_message (GtkPrinter *printer, priv = printer->priv; - if (safe_strcmp (priv->state_message, message) == 0) + if (g_strcmp0 (priv->state_message, message) == 0) return FALSE; g_free (priv->state_message); @@ -448,13 +522,13 @@ gtk_printer_set_state_message (GtkPrinter *printer, * gtk_printer_get_location: * @printer: a #GtkPrinter * - * Returns a description of the location of the printer. + * Returns a description of the location of the printer. * * Return value: the location of @printer * * Since: 2.10 */ -G_CONST_RETURN gchar * +const gchar * gtk_printer_get_location (GtkPrinter *printer) { g_return_val_if_fail (GTK_IS_PRINTER (printer), NULL); @@ -472,7 +546,7 @@ gtk_printer_set_location (GtkPrinter *printer, priv = printer->priv; - if (safe_strcmp (priv->location, location) == 0) + if (g_strcmp0 (priv->location, location) == 0) return FALSE; g_free (priv->location); @@ -492,7 +566,7 @@ gtk_printer_set_location (GtkPrinter *printer, * * Since: 2.10 */ -G_CONST_RETURN gchar * +const gchar * gtk_printer_get_icon_name (GtkPrinter *printer) { g_return_val_if_fail (GTK_IS_PRINTER (printer), NULL); @@ -553,9 +627,21 @@ gtk_printer_set_job_count (GtkPrinter *printer, return TRUE; } +/** + * gtk_printer_has_details: + * @printer: a #GtkPrinter + * + * Returns whether the printer details are available. + * + * Return value: %TRUE if @printer details are available + * + * Since: 2.12 + */ gboolean -_gtk_printer_has_details (GtkPrinter *printer) +gtk_printer_has_details (GtkPrinter *printer) { + g_return_val_if_fail (GTK_IS_PRINTER (printer), FALSE); + return printer->priv->has_details; } @@ -594,6 +680,79 @@ gtk_printer_set_is_active (GtkPrinter *printer, printer->priv->is_active = val; } +/** + * gtk_printer_is_paused: + * @printer: a #GtkPrinter + * + * Returns whether the printer is currently paused. + * A paused printer still accepts jobs, but it is not + * printing them. + * + * Return value: %TRUE if @printer is paused + * + * Since: 2.14 + */ +gboolean +gtk_printer_is_paused (GtkPrinter *printer) +{ + g_return_val_if_fail (GTK_IS_PRINTER (printer), TRUE); + + return printer->priv->is_paused; +} + +gboolean +gtk_printer_set_is_paused (GtkPrinter *printer, + gboolean val) +{ + GtkPrinterPrivate *priv; + + g_return_val_if_fail (GTK_IS_PRINTER (printer), FALSE); + + priv = printer->priv; + + if (val == priv->is_paused) + return FALSE; + + priv->is_paused = val; + + return TRUE; +} + +/** + * gtk_printer_is_accepting_jobs: + * @printer: a #GtkPrinter + * + * Returns whether the printer is accepting jobs + * + * Return value: %TRUE if @printer is accepting jobs + * + * Since: 2.14 + */ +gboolean +gtk_printer_is_accepting_jobs (GtkPrinter *printer) +{ + g_return_val_if_fail (GTK_IS_PRINTER (printer), TRUE); + + return printer->priv->is_accepting_jobs; +} + +gboolean +gtk_printer_set_is_accepting_jobs (GtkPrinter *printer, + gboolean val) +{ + GtkPrinterPrivate *priv; + + g_return_val_if_fail (GTK_IS_PRINTER (printer), FALSE); + + priv = printer->priv; + + if (val == priv->is_accepting_jobs) + return FALSE; + + priv->is_accepting_jobs = val; + + return TRUE; +} /** * gtk_printer_is_virtual: @@ -615,6 +774,62 @@ gtk_printer_is_virtual (GtkPrinter *printer) return printer->priv->is_virtual; } +/** + * gtk_printer_accepts_pdf: + * @printer: a #GtkPrinter + * + * Returns whether the printer accepts input in + * PDF format. + * + * Return value: %TRUE if @printer accepts PDF + * + * Since: 2.10 + */ +gboolean +gtk_printer_accepts_pdf (GtkPrinter *printer) +{ + g_return_val_if_fail (GTK_IS_PRINTER (printer), TRUE); + + return printer->priv->accepts_pdf; +} + +void +gtk_printer_set_accepts_pdf (GtkPrinter *printer, + gboolean val) +{ + g_return_if_fail (GTK_IS_PRINTER (printer)); + + printer->priv->accepts_pdf = val; +} + +/** + * gtk_printer_accepts_ps: + * @printer: a #GtkPrinter + * + * Returns whether the printer accepts input in + * PostScript format. + * + * Return value: %TRUE if @printer accepts PostScript + * + * Since: 2.10 + */ +gboolean +gtk_printer_accepts_ps (GtkPrinter *printer) +{ + g_return_val_if_fail (GTK_IS_PRINTER (printer), TRUE); + + return printer->priv->accepts_ps; +} + +void +gtk_printer_set_accepts_ps (GtkPrinter *printer, + gboolean val) +{ + g_return_if_fail (GTK_IS_PRINTER (printer)); + + printer->priv->accepts_ps = val; +} + gboolean gtk_printer_is_new (GtkPrinter *printer) { @@ -657,31 +872,45 @@ gtk_printer_set_is_default (GtkPrinter *printer, { g_return_if_fail (GTK_IS_PRINTER (printer)); - printer->priv->is_default = TRUE; + printer->priv->is_default = val; } +/** + * gtk_printer_request_details: + * @printer: a #GtkPrinter + * + * Requests the printer details. When the details are available, + * the #GtkPrinter::details-acquired signal will be emitted on @printer. + * + * Since: 2.12 + */ void -_gtk_printer_request_details (GtkPrinter *printer) +gtk_printer_request_details (GtkPrinter *printer) { - GtkPrintBackendIface *backend_iface = GTK_PRINT_BACKEND_GET_IFACE (printer->priv->backend); - return backend_iface->printer_request_details (printer); + GtkPrintBackendClass *backend_class; + + g_return_if_fail (GTK_IS_PRINTER (printer)); + + backend_class = GTK_PRINT_BACKEND_GET_CLASS (printer->priv->backend); + backend_class->printer_request_details (printer); } GtkPrinterOptionSet * -_gtk_printer_get_options (GtkPrinter *printer, - GtkPrintSettings *settings, - GtkPageSetup *page_setup) +_gtk_printer_get_options (GtkPrinter *printer, + GtkPrintSettings *settings, + GtkPageSetup *page_setup, + GtkPrintCapabilities capabilities) { - GtkPrintBackendIface *backend_iface = GTK_PRINT_BACKEND_GET_IFACE (printer->priv->backend); - return backend_iface->printer_get_options (printer, settings, page_setup); + GtkPrintBackendClass *backend_class = GTK_PRINT_BACKEND_GET_CLASS (printer->priv->backend); + return backend_class->printer_get_options (printer, settings, page_setup, capabilities); } gboolean _gtk_printer_mark_conflicts (GtkPrinter *printer, GtkPrinterOptionSet *options) { - GtkPrintBackendIface *backend_iface = GTK_PRINT_BACKEND_GET_IFACE (printer->priv->backend); - return backend_iface->printer_mark_conflicts (printer, options); + GtkPrintBackendClass *backend_class = GTK_PRINT_BACKEND_GET_CLASS (printer->priv->backend); + return backend_class->printer_mark_conflicts (printer, options); } void @@ -689,8 +918,8 @@ _gtk_printer_get_settings_from_options (GtkPrinter *printer, GtkPrinterOptionSet *options, GtkPrintSettings *settings) { - GtkPrintBackendIface *backend_iface = GTK_PRINT_BACKEND_GET_IFACE (printer->priv->backend); - return backend_iface->printer_get_settings_from_options (printer, options, settings); + GtkPrintBackendClass *backend_class = GTK_PRINT_BACKEND_GET_CLASS (printer->priv->backend); + backend_class->printer_get_settings_from_options (printer, options, settings); } void @@ -699,40 +928,371 @@ _gtk_printer_prepare_for_print (GtkPrinter *printer, GtkPrintSettings *settings, GtkPageSetup *page_setup) { - GtkPrintBackendIface *backend_iface = GTK_PRINT_BACKEND_GET_IFACE (printer->priv->backend); - return backend_iface->printer_prepare_for_print (printer, print_job, settings, page_setup); + GtkPrintBackendClass *backend_class = GTK_PRINT_BACKEND_GET_CLASS (printer->priv->backend); + backend_class->printer_prepare_for_print (printer, print_job, settings, page_setup); } cairo_surface_t * -_gtk_printer_create_cairo_surface (GtkPrinter *printer, - gdouble width, - gdouble height, - gint cache_fd) +_gtk_printer_create_cairo_surface (GtkPrinter *printer, + GtkPrintSettings *settings, + gdouble width, + gdouble height, + GIOChannel *cache_io) { - GtkPrintBackendIface *backend_iface = GTK_PRINT_BACKEND_GET_IFACE (printer->priv->backend); + GtkPrintBackendClass *backend_class = GTK_PRINT_BACKEND_GET_CLASS (printer->priv->backend); - return backend_iface->printer_create_cairo_surface (printer, width, height, cache_fd); + return backend_class->printer_create_cairo_surface (printer, settings, + width, height, cache_io); } +/** + * gtk_printer_list_papers: + * @printer: a #GtkPrinter + * + * Lists all the paper sizes @printer supports. + * This will return and empty list unless the printer's details are + * available, see gtk_printer_has_details() and gtk_printer_request_details(). + * + * Return value: (element-type GtkPageSetup) (transfer full): a newly allocated list of newly allocated #GtkPageSetup s. + * + * Since: 2.12 + */ GList * -_gtk_printer_list_papers (GtkPrinter *printer) +gtk_printer_list_papers (GtkPrinter *printer) +{ + GtkPrintBackendClass *backend_class; + + g_return_val_if_fail (GTK_IS_PRINTER (printer), NULL); + + backend_class = GTK_PRINT_BACKEND_GET_CLASS (printer->priv->backend); + return backend_class->printer_list_papers (printer); +} + +/** + * gtk_printer_get_default_page_size: + * @printer: a #GtkPrinter + * + * Returns default page size of @printer. + * + * Return value: a newly allocated #GtkPageSetup with default page size of the printer. + * + * Since: 2.14 + */ +GtkPageSetup * +gtk_printer_get_default_page_size (GtkPrinter *printer) +{ + GtkPrintBackendClass *backend_class; + + g_return_val_if_fail (GTK_IS_PRINTER (printer), NULL); + + backend_class = GTK_PRINT_BACKEND_GET_CLASS (printer->priv->backend); + return backend_class->printer_get_default_page_size (printer); +} + +/** + * gtk_printer_get_hard_margins: + * @printer: a #GtkPrinter + * @top: (out): a location to store the top margin in + * @bottom: (out): a location to store the bottom margin in + * @left: (out): a location to store the left margin in + * @right: (out): a location to store the right margin in + * + * Retrieve the hard margins of @printer, i.e. the margins that define + * the area at the borders of the paper that the printer cannot print to. + * + * Note: This will not succeed unless the printer's details are available, + * see gtk_printer_has_details() and gtk_printer_request_details(). + * + * Return value: %TRUE iff the hard margins were retrieved + * + * Since: 2.20 + */ +gboolean +gtk_printer_get_hard_margins (GtkPrinter *printer, + gdouble *top, + gdouble *bottom, + gdouble *left, + gdouble *right) +{ + GtkPrintBackendClass *backend_class = GTK_PRINT_BACKEND_GET_CLASS (printer->priv->backend); + + return backend_class->printer_get_hard_margins (printer, top, bottom, left, right); +} + +/** + * gtk_printer_get_capabilities: + * @printer: a #GtkPrinter + * + * Returns the printer's capabilities. + * + * This is useful when you're using #GtkPrintUnixDialog's manual-capabilities + * setting and need to know which settings the printer can handle and which + * you must handle yourself. + * + * This will return 0 unless the printer's details are available, see + * gtk_printer_has_details() and gtk_printer_request_details(). + * + * Return value: the printer's capabilities + * + * Since: 2.12 + */ +GtkPrintCapabilities +gtk_printer_get_capabilities (GtkPrinter *printer) { - GtkPrintBackendIface *backend_iface = GTK_PRINT_BACKEND_GET_IFACE (printer->priv->backend); + GtkPrintBackendClass *backend_class; + + g_return_val_if_fail (GTK_IS_PRINTER (printer), 0); - return backend_iface->printer_list_papers (printer); + backend_class = GTK_PRINT_BACKEND_GET_CLASS (printer->priv->backend); + return backend_class->printer_get_capabilities (printer); } +/** + * gtk_printer_compare: + * @a: a #GtkPrinter + * @b: another #GtkPrinter + * + * Compares two printers. + * + * Return value: 0 if the printer match, a negative value if @a < @b, + * or a positive value if @a > @b + * + * Since: 2.10 + */ +gint +gtk_printer_compare (GtkPrinter *a, + GtkPrinter *b) +{ + const char *name_a, *name_b; + + g_assert (GTK_IS_PRINTER (a) && GTK_IS_PRINTER (b)); + + name_a = gtk_printer_get_name (a); + name_b = gtk_printer_get_name (b); + if (name_a == NULL && name_b == NULL) + return 0; + else if (name_a == NULL) + return G_MAXINT; + else if (name_b == NULL) + return G_MININT; + else + return g_ascii_strcasecmp (name_a, name_b); +} + + +typedef struct +{ + GList *backends; + GtkPrinterFunc func; + gpointer data; + GDestroyNotify destroy; + GMainLoop *loop; +} PrinterList; + +static void list_done_cb (GtkPrintBackend *backend, + PrinterList *printer_list); + +static void +stop_enumeration (PrinterList *printer_list) +{ + GList *list, *next; + GtkPrintBackend *backend; + + for (list = printer_list->backends; list; list = next) + { + next = list->next; + backend = GTK_PRINT_BACKEND (list->data); + list_done_cb (backend, printer_list); + } +} + +static void +free_printer_list (PrinterList *printer_list) +{ + if (printer_list->destroy) + printer_list->destroy (printer_list->data); + + if (printer_list->loop) + { + g_main_loop_quit (printer_list->loop); + g_main_loop_unref (printer_list->loop); + } + + g_free (printer_list); +} + +static gboolean +list_added_cb (GtkPrintBackend *backend, + GtkPrinter *printer, + PrinterList *printer_list) +{ + if (printer_list->func (printer, printer_list->data)) + { + stop_enumeration (printer_list); + return TRUE; + } + + return FALSE; +} + +static void +backend_status_changed (GObject *object, + GParamSpec *pspec, + gpointer data) +{ + GtkPrintBackend *backend = GTK_PRINT_BACKEND (object); + PrinterList *printer_list = data; + GtkPrintBackendStatus status; + + g_object_get (backend, "status", &status, NULL); + + if (status == GTK_PRINT_BACKEND_STATUS_UNAVAILABLE) + list_done_cb (backend, printer_list); +} + +static void +list_printers_remove_backend (PrinterList *printer_list, + GtkPrintBackend *backend) +{ + printer_list->backends = g_list_remove (printer_list->backends, backend); + gtk_print_backend_destroy (backend); + g_object_unref (backend); + + if (printer_list->backends == NULL) + free_printer_list (printer_list); +} + +static void +list_done_cb (GtkPrintBackend *backend, + PrinterList *printer_list) +{ + g_signal_handlers_disconnect_by_func (backend, list_added_cb, printer_list); + g_signal_handlers_disconnect_by_func (backend, list_done_cb, printer_list); + g_signal_handlers_disconnect_by_func (backend, backend_status_changed, printer_list); + + list_printers_remove_backend(printer_list, backend); +} + +static gboolean +list_printers_init (PrinterList *printer_list, + GtkPrintBackend *backend) +{ + GList *list, *node; + GtkPrintBackendStatus status; + + list = gtk_print_backend_get_printer_list (backend); + + for (node = list; node != NULL; node = node->next) + { + if (list_added_cb (backend, node->data, printer_list)) + { + g_list_free (list); + return TRUE; + } + } + + g_list_free (list); + + g_object_get (backend, "status", &status, NULL); + + if (status == GTK_PRINT_BACKEND_STATUS_UNAVAILABLE || + gtk_print_backend_printer_list_is_done (backend)) + list_printers_remove_backend(printer_list, backend); + else + { + g_signal_connect (backend, "printer-added", + (GCallback) list_added_cb, + printer_list); + g_signal_connect (backend, "printer-list-done", + (GCallback) list_done_cb, + printer_list); + g_signal_connect (backend, "notify::status", + (GCallback) backend_status_changed, + printer_list); + } + + return FALSE; +} + +/** + * gtk_enumerate_printers: + * @func: a function to call for each printer + * @data: user data to pass to @func + * @destroy: function to call if @data is no longer needed + * @wait: if %TRUE, wait in a recursive mainloop until + * all printers are enumerated; otherwise return early + * + * Calls a function for all #GtkPrinters. + * If @func returns %TRUE, the enumeration is stopped. + * + * Since: 2.10 + */ void -_gtk_printer_get_hard_margins (GtkPrinter *printer, - gdouble *top, - gdouble *bottom, - gdouble *left, - gdouble *right) +gtk_enumerate_printers (GtkPrinterFunc func, + gpointer data, + GDestroyNotify destroy, + gboolean wait) { - GtkPrintBackendIface *backend_iface = GTK_PRINT_BACKEND_GET_IFACE (printer->priv->backend); + PrinterList *printer_list; + GList *node, *next; + GtkPrintBackend *backend; + + printer_list = g_new0 (PrinterList, 1); - backend_iface->printer_get_hard_margins (printer, top, bottom, left, right); + printer_list->func = func; + printer_list->data = data; + printer_list->destroy = destroy; + + if (g_module_supported ()) + printer_list->backends = gtk_print_backend_load_modules (); + + if (printer_list->backends == NULL) + { + free_printer_list (printer_list); + return; + } + + for (node = printer_list->backends; node != NULL; node = next) + { + next = node->next; + backend = GTK_PRINT_BACKEND (node->data); + if (list_printers_init (printer_list, backend)) + return; + } + + if (wait && printer_list->backends) + { + printer_list->loop = g_main_loop_new (NULL, FALSE); + + gdk_threads_leave (); + g_main_loop_run (printer_list->loop); + gdk_threads_enter (); + } } -#define __GTK_PRINTER_C__ -#include "gtkaliasdef.c" +GType +gtk_print_capabilities_get_type (void) +{ + static GType etype = 0; + + if (G_UNLIKELY (etype == 0)) + { + static const GFlagsValue values[] = { + { GTK_PRINT_CAPABILITY_PAGE_SET, "GTK_PRINT_CAPABILITY_PAGE_SET", "page-set" }, + { GTK_PRINT_CAPABILITY_COPIES, "GTK_PRINT_CAPABILITY_COPIES", "copies" }, + { GTK_PRINT_CAPABILITY_COLLATE, "GTK_PRINT_CAPABILITY_COLLATE", "collate" }, + { GTK_PRINT_CAPABILITY_REVERSE, "GTK_PRINT_CAPABILITY_REVERSE", "reverse" }, + { GTK_PRINT_CAPABILITY_SCALE, "GTK_PRINT_CAPABILITY_SCALE", "scale" }, + { GTK_PRINT_CAPABILITY_GENERATE_PDF, "GTK_PRINT_CAPABILITY_GENERATE_PDF", "generate-pdf" }, + { GTK_PRINT_CAPABILITY_GENERATE_PS, "GTK_PRINT_CAPABILITY_GENERATE_PS", "generate-ps" }, + { GTK_PRINT_CAPABILITY_PREVIEW, "GTK_PRINT_CAPABILITY_PREVIEW", "preview" }, + { GTK_PRINT_CAPABILITY_NUMBER_UP, "GTK_PRINT_CAPABILITY_NUMBER_UP", "number-up"}, + { GTK_PRINT_CAPABILITY_NUMBER_UP_LAYOUT, "GTK_PRINT_CAPABILITY_NUMBER_UP_LAYOUT", "number-up-layout" }, + { 0, NULL, NULL } + }; + + etype = g_flags_register_static (I_("GtkPrintCapabilities"), values); + } + + return etype; +}