[gnome-control-center] printers: Add PpNewPrinter object for installation of new printer
- From: Marek KaÅÃk <mkasik src gnome org>
- To: commits-list gnome org
- Cc:
- Subject: [gnome-control-center] printers: Add PpNewPrinter object for installation of new printer
- Date: Tue, 4 Sep 2012 12:11:39 +0000 (UTC)
commit dea424dbeeaabb46cb0a5e9d950371c837babb6e
Author: Marek Kasik <mkasik redhat com>
Date: Mon Sep 3 20:44:32 2012 +0200
printers: Add PpNewPrinter object for installation of new printer
PpNewPrinter contains asynchronous method for installation of
new printer. The new printer is specified by given parameters (e.g. name,
device-id, device-uri, ppd-name, info, location, ...). (#683229)
panels/printers/Makefile.am | 2 +
panels/printers/pp-new-printer.c | 1444 ++++++++++++++++++++++++++++++++++++++
panels/printers/pp-new-printer.h | 66 ++
3 files changed, 1512 insertions(+), 0 deletions(-)
---
diff --git a/panels/printers/Makefile.am b/panels/printers/Makefile.am
index ad79c0d..195f215 100644
--- a/panels/printers/Makefile.am
+++ b/panels/printers/Makefile.am
@@ -22,6 +22,8 @@ ccpanels_LTLIBRARIES = libprinters.la
libprinters_la_SOURCES = \
printers-module.c \
+ pp-new-printer.c \
+ pp-new-printer.h \
pp-maintenance-command.c \
pp-maintenance-command.h \
pp-host.c \
diff --git a/panels/printers/pp-new-printer.c b/panels/printers/pp-new-printer.c
new file mode 100644
index 0000000..081d60f
--- /dev/null
+++ b/panels/printers/pp-new-printer.c
@@ -0,0 +1,1444 @@
+/* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 8 -*-
+ *
+ * Copyright 2012 Red Hat, Inc,
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+ *
+ * Author: Marek Kasik <mkasik redhat com>
+ */
+
+#include "pp-new-printer.h"
+
+#include <glib/gstdio.h>
+#include <glib/gi18n.h>
+
+#include "pp-utils.h"
+#include "pp-maintenance-command.h"
+
+#define PACKAGE_KIT_BUS "org.freedesktop.PackageKit"
+#define PACKAGE_KIT_PATH "/org/freedesktop/PackageKit"
+#define PACKAGE_KIT_MODIFY_IFACE "org.freedesktop.PackageKit.Modify"
+#define PACKAGE_KIT_QUERY_IFACE "org.freedesktop.PackageKit.Query"
+
+#define DBUS_TIMEOUT 120000
+#define DBUS_TIMEOUT_LONG 600000
+
+#if (CUPS_VERSION_MAJOR > 1) || (CUPS_VERSION_MINOR > 5)
+#define HAVE_CUPS_1_6 1
+#endif
+
+#ifndef HAVE_CUPS_1_6
+#define ippGetState(ipp) ipp->state
+#endif
+
+struct _PpNewPrinterPrivate
+{
+ gchar *name;
+ gchar *original_name;
+ gchar *device_uri;
+ gchar *device_id;
+ gchar *ppd_name;
+ gchar *ppd_file_name;
+ gchar *info;
+ gchar *location;
+ gchar *make_and_model;
+ gchar *host_name;
+ gint host_port;
+ gboolean is_network_device;
+ guint window_id;
+ gboolean unlink_ppd_file;
+
+ GSimpleAsyncResult *res;
+ GCancellable *cancellable;
+};
+
+G_DEFINE_TYPE (PpNewPrinter, pp_new_printer, G_TYPE_OBJECT);
+
+enum {
+ PROP_0 = 0,
+ PROP_NAME,
+ PROP_ORIGINAL_NAME,
+ PROP_DEVICE_URI,
+ PROP_DEVICE_ID,
+ PROP_PPD_NAME,
+ PROP_PPD_FILE_NAME,
+ PROP_INFO,
+ PROP_LOCATION,
+ PROP_MAKE_AND_MODEL,
+ PROP_HOST_NAME,
+ PROP_HOST_PORT,
+ PROP_IS_NETWORK_DEVICE,
+ PROP_WINDOW_ID
+};
+
+static void
+pp_new_printer_finalize (GObject *object)
+{
+ PpNewPrinterPrivate *priv;
+
+ priv = PP_NEW_PRINTER (object)->priv;
+
+ if (priv->unlink_ppd_file && priv->ppd_file_name)
+ g_unlink (priv->ppd_file_name);
+
+ g_clear_pointer (&priv->name, g_free);
+ g_clear_pointer (&priv->original_name, g_free);
+ g_clear_pointer (&priv->device_uri, g_free);
+ g_clear_pointer (&priv->device_id, g_free);
+ g_clear_pointer (&priv->ppd_name, g_free);
+ g_clear_pointer (&priv->ppd_file_name, g_free);
+ g_clear_pointer (&priv->info, g_free);
+ g_clear_pointer (&priv->location, g_free);
+ g_clear_pointer (&priv->make_and_model, g_free);
+ g_clear_pointer (&priv->host_name, g_free);
+
+ if (priv->res)
+ g_object_unref (priv->res);
+
+ if (priv->cancellable)
+ g_object_unref (priv->cancellable);
+
+ G_OBJECT_CLASS (pp_new_printer_parent_class)->finalize (object);
+}
+
+static void
+pp_new_printer_get_property (GObject *object,
+ guint prop_id,
+ GValue *value,
+ GParamSpec *param_spec)
+{
+ PpNewPrinter *self;
+
+ self = PP_NEW_PRINTER (object);
+
+ switch (prop_id)
+ {
+ case PROP_NAME:
+ g_value_set_string (value, self->priv->name);
+ break;
+ case PROP_ORIGINAL_NAME:
+ g_value_set_string (value, self->priv->original_name);
+ break;
+ case PROP_DEVICE_URI:
+ g_value_set_string (value, self->priv->device_uri);
+ break;
+ case PROP_DEVICE_ID:
+ g_value_set_string (value, self->priv->device_id);
+ break;
+ case PROP_PPD_NAME:
+ g_value_set_string (value, self->priv->ppd_name);
+ break;
+ case PROP_PPD_FILE_NAME:
+ g_value_set_string (value, self->priv->ppd_file_name);
+ break;
+ case PROP_INFO:
+ g_value_set_string (value, self->priv->info);
+ break;
+ case PROP_LOCATION:
+ g_value_set_string (value, self->priv->location);
+ break;
+ case PROP_MAKE_AND_MODEL:
+ g_value_set_string (value, self->priv->make_and_model);
+ break;
+ case PROP_HOST_NAME:
+ g_value_set_string (value, self->priv->host_name);
+ break;
+ case PROP_HOST_PORT:
+ g_value_set_int (value, self->priv->host_port);
+ break;
+ case PROP_IS_NETWORK_DEVICE:
+ g_value_set_boolean (value, self->priv->is_network_device);
+ break;
+ case PROP_WINDOW_ID:
+ g_value_set_int (value, self->priv->window_id);
+ break;
+ default:
+ G_OBJECT_WARN_INVALID_PROPERTY_ID (object,
+ prop_id,
+ param_spec);
+ break;
+ }
+}
+
+static void
+pp_new_printer_set_property (GObject *object,
+ guint prop_id,
+ const GValue *value,
+ GParamSpec *param_spec)
+{
+ PpNewPrinter *self = PP_NEW_PRINTER (object);
+
+ switch (prop_id)
+ {
+ case PROP_NAME:
+ g_free (self->priv->name);
+ self->priv->name = g_value_dup_string (value);
+ break;
+ case PROP_ORIGINAL_NAME:
+ g_free (self->priv->original_name);
+ self->priv->original_name = g_value_dup_string (value);
+ break;
+ case PROP_DEVICE_URI:
+ g_free (self->priv->device_uri);
+ self->priv->device_uri = g_value_dup_string (value);
+ break;
+ case PROP_DEVICE_ID:
+ g_free (self->priv->device_id);
+ self->priv->device_id = g_value_dup_string (value);
+ break;
+ case PROP_PPD_NAME:
+ g_free (self->priv->ppd_name);
+ self->priv->ppd_name = g_value_dup_string (value);
+ break;
+ case PROP_PPD_FILE_NAME:
+ g_free (self->priv->ppd_file_name);
+ self->priv->ppd_file_name = g_value_dup_string (value);
+ break;
+ case PROP_INFO:
+ g_free (self->priv->info);
+ self->priv->info = g_value_dup_string (value);
+ break;
+ case PROP_LOCATION:
+ g_free (self->priv->location);
+ self->priv->location = g_value_dup_string (value);
+ break;
+ case PROP_MAKE_AND_MODEL:
+ g_free (self->priv->make_and_model);
+ self->priv->make_and_model = g_value_dup_string (value);
+ break;
+ case PROP_HOST_NAME:
+ g_free (self->priv->host_name);
+ self->priv->host_name = g_value_dup_string (value);
+ break;
+ case PROP_HOST_PORT:
+ self->priv->host_port = g_value_get_int (value);
+ break;
+ case PROP_IS_NETWORK_DEVICE:
+ self->priv->is_network_device = g_value_get_boolean (value);
+ break;
+ case PROP_WINDOW_ID:
+ self->priv->window_id = g_value_get_int (value);
+ break;
+ default:
+ G_OBJECT_WARN_INVALID_PROPERTY_ID (object,
+ prop_id,
+ param_spec);
+ break;
+ }
+}
+
+static void
+pp_new_printer_class_init (PpNewPrinterClass *klass)
+{
+ GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
+
+ g_type_class_add_private (klass, sizeof (PpNewPrinterPrivate));
+
+ gobject_class->set_property = pp_new_printer_set_property;
+ gobject_class->get_property = pp_new_printer_get_property;
+
+ gobject_class->finalize = pp_new_printer_finalize;
+
+ g_object_class_install_property (gobject_class, PROP_NAME,
+ g_param_spec_string ("name",
+ "Name",
+ "The new printer's name",
+ NULL,
+ G_PARAM_READWRITE));
+
+ g_object_class_install_property (gobject_class, PROP_ORIGINAL_NAME,
+ g_param_spec_string ("original-name",
+ "Original name",
+ "Original name of the new printer",
+ NULL,
+ G_PARAM_READWRITE));
+
+ g_object_class_install_property (gobject_class, PROP_DEVICE_URI,
+ g_param_spec_string ("device-uri",
+ "Device URI",
+ "The new printer's device URI",
+ NULL,
+ G_PARAM_READWRITE));
+
+ g_object_class_install_property (gobject_class, PROP_DEVICE_ID,
+ g_param_spec_string ("device-id",
+ "DeviceID",
+ "The new printer's DeviceID",
+ NULL,
+ G_PARAM_READWRITE));
+
+ g_object_class_install_property (gobject_class, PROP_PPD_NAME,
+ g_param_spec_string ("ppd-name",
+ "PPD name",
+ "Name of PPD for the new printer",
+ NULL,
+ G_PARAM_READWRITE));
+
+ g_object_class_install_property (gobject_class, PROP_PPD_FILE_NAME,
+ g_param_spec_string ("ppd-file-name",
+ "PPD file name",
+ "PPD file for the new printer",
+ NULL,
+ G_PARAM_READWRITE));
+
+ g_object_class_install_property (gobject_class, PROP_INFO,
+ g_param_spec_string ("info",
+ "Printer info",
+ "The new printer's info",
+ NULL,
+ G_PARAM_READWRITE));
+
+ g_object_class_install_property (gobject_class, PROP_LOCATION,
+ g_param_spec_string ("location",
+ "Printer location",
+ "The new printer's location",
+ NULL,
+ G_PARAM_READWRITE));
+
+ g_object_class_install_property (gobject_class, PROP_MAKE_AND_MODEL,
+ g_param_spec_string ("make-and-model",
+ "Printer make and model",
+ "The new printer's make and model",
+ NULL,
+ G_PARAM_READWRITE));
+
+ g_object_class_install_property (gobject_class, PROP_HOST_NAME,
+ g_param_spec_string ("host-name",
+ "Hostname",
+ "The new printer's hostname",
+ NULL,
+ G_PARAM_READWRITE));
+
+ g_object_class_install_property (gobject_class, PROP_HOST_PORT,
+ g_param_spec_int ("host-port",
+ "Host port",
+ "The port of the host",
+ 0, G_MAXINT32, 631,
+ G_PARAM_READWRITE));
+
+ g_object_class_install_property (gobject_class, PROP_IS_NETWORK_DEVICE,
+ g_param_spec_boolean ("is-network-device",
+ "Network device",
+ "Whether the new printer is a network device",
+ FALSE,
+ G_PARAM_READWRITE));
+
+ g_object_class_install_property (gobject_class, PROP_WINDOW_ID,
+ g_param_spec_int ("window-id",
+ "WindowID",
+ "Window ID of parent window",
+ 0, G_MAXINT32, 631,
+ G_PARAM_READWRITE));
+}
+
+static void
+pp_new_printer_init (PpNewPrinter *printer)
+{
+ printer->priv = G_TYPE_INSTANCE_GET_PRIVATE (printer,
+ PP_TYPE_NEW_PRINTER,
+ PpNewPrinterPrivate);
+
+ printer->priv->unlink_ppd_file = FALSE;
+ printer->priv->cancellable = NULL;
+ printer->priv->res = NULL;
+}
+
+PpNewPrinter *
+pp_new_printer_new ()
+{
+ return g_object_new (PP_TYPE_NEW_PRINTER, NULL);
+}
+
+static void printer_configure_async (PpNewPrinter *new_printer);
+
+static void
+_pp_new_printer_add_async_cb (gboolean success,
+ PpNewPrinter *printer)
+{
+ PpNewPrinterPrivate *priv = printer->priv;
+
+ if (!success)
+ {
+ g_simple_async_result_set_error (priv->res,
+ G_IO_ERROR,
+ G_IO_ERROR_FAILED,
+ "Installation of the new printer failed.");
+ }
+
+ g_simple_async_result_set_op_res_gboolean (priv->res, success);
+ g_simple_async_result_complete_in_idle (priv->res);
+}
+
+static void
+printer_add_real_async_cb (cups_dest_t *destination,
+ gpointer user_data)
+{
+ PpNewPrinter *printer = (PpNewPrinter *) user_data;
+ gboolean success = FALSE;
+
+ if (destination)
+ {
+ success = TRUE;
+ cupsFreeDests (1, destination);
+ }
+
+ if (success)
+ {
+ printer_configure_async (printer);
+ }
+ else
+ {
+ _pp_new_printer_add_async_cb (FALSE, printer);
+ }
+}
+
+static void
+printer_add_real_async_dbus_cb (GObject *source_object,
+ GAsyncResult *res,
+ gpointer user_data)
+{
+ PpNewPrinter *printer;
+ PpNewPrinterPrivate *priv;
+ GVariant *output;
+ GError *error = NULL;
+
+ output = g_dbus_connection_call_finish (G_DBUS_CONNECTION (source_object),
+ res,
+ &error);
+ g_object_unref (source_object);
+
+ if (output)
+ {
+ const gchar *ret_error;
+
+ g_variant_get (output, "(&s)", &ret_error);
+ if (ret_error[0] != '\0')
+ {
+ g_warning ("%s", ret_error);
+ }
+
+ g_variant_unref (output);
+ }
+ else
+ {
+ if (error->domain != G_IO_ERROR ||
+ error->code != G_IO_ERROR_CANCELLED)
+ g_warning ("%s", error->message);
+ }
+
+ if (!error ||
+ error->domain != G_IO_ERROR ||
+ error->code != G_IO_ERROR_CANCELLED)
+ {
+ printer = (PpNewPrinter *) user_data;
+ priv = printer->priv;
+
+ get_named_dest_async (priv->name,
+ printer_add_real_async_cb,
+ printer);
+ }
+
+ if (error)
+ g_error_free (error);
+}
+
+static void
+printer_add_real_async (PpNewPrinter *printer)
+{
+ PpNewPrinterPrivate *priv = printer->priv;
+ GDBusConnection *bus;
+ GError *error = NULL;
+
+ if (!priv->ppd_name && !priv->ppd_file_name)
+ {
+ _pp_new_printer_add_async_cb (FALSE, printer);
+ return;
+ }
+
+ bus = g_bus_get_sync (G_BUS_TYPE_SYSTEM, NULL, &error);
+ if (!bus)
+ {
+ g_warning ("Failed to get system bus: %s", error->message);
+ g_error_free (error);
+ _pp_new_printer_add_async_cb (FALSE, printer);
+ return;
+ }
+
+ g_dbus_connection_call (bus,
+ MECHANISM_BUS,
+ "/",
+ MECHANISM_BUS,
+ priv->ppd_name ? "PrinterAdd" : "PrinterAddWithPpdFile",
+ g_variant_new ("(sssss)",
+ priv->name,
+ priv->device_uri,
+ priv->ppd_name ? priv->ppd_name : priv->ppd_file_name,
+ priv->info ? priv->info : "",
+ priv->location ? priv->location : ""),
+ G_VARIANT_TYPE ("(s)"),
+ G_DBUS_CALL_FLAGS_NONE,
+ DBUS_TIMEOUT,
+ NULL,
+ printer_add_real_async_dbus_cb,
+ printer);
+}
+
+static PPDName *
+get_ppd_item_from_output (GVariant *output)
+{
+ GVariant *array;
+ PPDName *ppd_item = NULL;
+ gint j;
+ static const char * const match_levels[] = {
+ "exact-cmd",
+ "exact",
+ "close",
+ "generic",
+ "none"};
+
+ if (output)
+ {
+ g_variant_get (output, "(@a(ss))", &array);
+ if (array)
+ {
+ GVariantIter *iter;
+ GVariant *item;
+ gchar *driver;
+ gchar *match;
+
+ for (j = 0; j < G_N_ELEMENTS (match_levels) && !ppd_item; j++)
+ {
+ g_variant_get (array, "a(ss)", &iter);
+ while ((item = g_variant_iter_next_value (iter)) && !ppd_item)
+ {
+ g_variant_get (item, "(ss)", &driver, &match);
+ if (g_str_equal (match, match_levels[j]))
+ {
+ ppd_item = g_new0 (PPDName, 1);
+ ppd_item->ppd_name = g_strdup (driver);
+
+ if (g_strcmp0 (match, "exact-cmd") == 0)
+ ppd_item->ppd_match_level = PPD_EXACT_CMD_MATCH;
+ else if (g_strcmp0 (match, "exact") == 0)
+ ppd_item->ppd_match_level = PPD_EXACT_MATCH;
+ else if (g_strcmp0 (match, "close") == 0)
+ ppd_item->ppd_match_level = PPD_CLOSE_MATCH;
+ else if (g_strcmp0 (match, "generic") == 0)
+ ppd_item->ppd_match_level = PPD_GENERIC_MATCH;
+ else if (g_strcmp0 (match, "none") == 0)
+ ppd_item->ppd_match_level = PPD_NO_MATCH;
+ }
+
+ g_free (driver);
+ g_free (match);
+ g_variant_unref (item);
+ }
+ }
+
+ g_variant_unref (array);
+ }
+ }
+
+ return ppd_item;
+}
+
+
+static void
+printer_add_async_scb3 (GObject *source_object,
+ GAsyncResult *res,
+ gpointer user_data)
+{
+ PpNewPrinter *printer = (PpNewPrinter *) user_data;
+ PpNewPrinterPrivate *priv = printer->priv;
+ GVariant *output;
+ PPDName *ppd_item = NULL;
+ GError *error = NULL;
+
+ output = g_dbus_connection_call_finish (G_DBUS_CONNECTION (source_object),
+ res,
+ &error);
+ g_object_unref (source_object);
+
+ if (output)
+ {
+ ppd_item = get_ppd_item_from_output (output);
+ g_variant_unref (output);
+ }
+ else
+ {
+ if (error->domain != G_IO_ERROR ||
+ error->code != G_IO_ERROR_CANCELLED)
+ g_warning ("%s", error->message);
+ }
+
+ if ((!error ||
+ error->domain != G_IO_ERROR ||
+ error->code != G_IO_ERROR_CANCELLED) &&
+ ppd_item && ppd_item->ppd_name)
+ {
+ priv->ppd_name = g_strdup (ppd_item->ppd_name);
+ printer_add_real_async (printer);
+ }
+ else
+ {
+ _pp_new_printer_add_async_cb (FALSE, printer);
+ }
+
+ if (error)
+ {
+ g_error_free (error);
+ }
+
+ if (ppd_item)
+ {
+ g_free (ppd_item->ppd_name);
+ g_free (ppd_item);
+ }
+}
+
+static void
+install_printer_drivers_cb (GObject *source_object,
+ GAsyncResult *res,
+ gpointer user_data)
+{
+ PpNewPrinterPrivate *priv;
+ PpNewPrinter *printer;
+ GVariant *output;
+ GError *error = NULL;
+
+ output = g_dbus_connection_call_finish (G_DBUS_CONNECTION (source_object),
+ res,
+ &error);
+ g_object_unref (source_object);
+
+ if (output)
+ {
+ g_variant_unref (output);
+ }
+ else
+ {
+ if (error->domain != G_IO_ERROR ||
+ error->code != G_IO_ERROR_CANCELLED)
+ g_warning ("%s", error->message);
+ }
+
+ if (!error ||
+ error->domain != G_IO_ERROR ||
+ error->code != G_IO_ERROR_CANCELLED)
+ {
+ GDBusConnection *bus;
+ GError *error = NULL;
+
+ printer = (PpNewPrinter *) user_data;
+ priv = printer->priv;
+
+ /* Try whether CUPS has a driver for the new printer */
+ bus = g_bus_get_sync (G_BUS_TYPE_SESSION, NULL, &error);
+ if (bus)
+ {
+ g_dbus_connection_call (bus,
+ SCP_BUS,
+ SCP_PATH,
+ SCP_IFACE,
+ "GetBestDrivers",
+ g_variant_new ("(sss)",
+ priv->device_id,
+ priv->make_and_model ? priv->make_and_model : "",
+ priv->device_uri ? priv->device_uri : ""),
+ G_VARIANT_TYPE ("(a(ss))"),
+ G_DBUS_CALL_FLAGS_NONE,
+ DBUS_TIMEOUT_LONG,
+ priv->cancellable,
+ printer_add_async_scb3,
+ printer);
+ }
+ else
+ {
+ g_warning ("Failed to get system bus: %s", error->message);
+ g_error_free (error);
+ _pp_new_printer_add_async_cb (FALSE, printer);
+ }
+ }
+
+ if (error)
+ g_error_free (error);
+}
+
+static void
+printer_add_async_scb (GObject *source_object,
+ GAsyncResult *res,
+ gpointer user_data)
+{
+ PpNewPrinter *printer = (PpNewPrinter *) user_data;
+ PpNewPrinterPrivate *priv = printer->priv;
+ GDBusConnection *bus;
+ GVariantBuilder array_builder;
+ GVariant *output;
+ PPDName *ppd_item = NULL;
+ GError *error = NULL;
+
+ output = g_dbus_connection_call_finish (G_DBUS_CONNECTION (source_object),
+ res,
+ &error);
+ g_object_unref (source_object);
+
+ if (output)
+ {
+ ppd_item = get_ppd_item_from_output (output);
+ g_variant_unref (output);
+ }
+ else
+ {
+ if (error->domain != G_IO_ERROR ||
+ error->code != G_IO_ERROR_CANCELLED)
+ g_warning ("%s", error->message);
+ g_error_free (error);
+ }
+
+ if (!error ||
+ error->domain != G_IO_ERROR ||
+ error->code != G_IO_ERROR_CANCELLED)
+ {
+ if (ppd_item == NULL || ppd_item->ppd_match_level < PPD_EXACT_MATCH)
+ {
+ bus = g_bus_get_sync (G_BUS_TYPE_SESSION, NULL, &error);
+ if (bus)
+ {
+ g_variant_builder_init (&array_builder, G_VARIANT_TYPE ("as"));
+ g_variant_builder_add (&array_builder, "s", priv->device_id);
+
+ g_dbus_connection_call (bus,
+ PACKAGE_KIT_BUS,
+ PACKAGE_KIT_PATH,
+ PACKAGE_KIT_MODIFY_IFACE,
+ "InstallPrinterDrivers",
+ g_variant_new ("(uass)",
+ priv->window_id,
+ &array_builder,
+ "hide-finished"),
+ G_VARIANT_TYPE ("()"),
+ G_DBUS_CALL_FLAGS_NONE,
+ DBUS_TIMEOUT_LONG,
+ NULL,
+ install_printer_drivers_cb,
+ printer);
+ }
+ else
+ {
+ g_warning ("Failed to get session bus: %s", error->message);
+ g_error_free (error);
+ _pp_new_printer_add_async_cb (FALSE, printer);
+ }
+ }
+ else if (ppd_item && ppd_item->ppd_name)
+ {
+ priv->ppd_name = g_strdup (ppd_item->ppd_name);
+ printer_add_real_async (printer);
+ }
+ else
+ {
+ _pp_new_printer_add_async_cb (FALSE, printer);
+ }
+ }
+
+ if (ppd_item)
+ {
+ g_free (ppd_item->ppd_name);
+ g_free (ppd_item);
+ }
+}
+
+static void
+printer_add_async_scb4 (const gchar *ppd_filename,
+ gpointer user_data)
+{
+ PpNewPrinter *printer = (PpNewPrinter *) user_data;
+ PpNewPrinterPrivate *priv = printer->priv;
+
+ priv->ppd_file_name = g_strdup (ppd_filename);
+ if (priv->ppd_file_name)
+ {
+ priv->unlink_ppd_file = TRUE;
+ printer_add_real_async (printer);
+ }
+ else
+ {
+ _pp_new_printer_add_async_cb (FALSE, printer);
+ }
+}
+
+static GList *
+glist_uniq (GList *list)
+{
+ GList *result = NULL;
+ GList *iter = NULL;
+ GList *tmp = NULL;
+
+ for (iter = list; iter; iter = iter->next)
+ {
+ if (tmp == NULL ||
+ g_strcmp0 ((gchar *) tmp->data, (gchar *) iter->data) != 0)
+ {
+ tmp = iter;
+ result = g_list_append (result, g_strdup (iter->data));
+ }
+ }
+
+ g_list_free_full (list, g_free);
+
+ return result;
+}
+
+typedef struct
+{
+ PpNewPrinter *new_printer;
+ GCancellable *cancellable;
+ gboolean set_accept_jobs_finished;
+ gboolean set_enabled_finished;
+ gboolean autoconfigure_finished;
+ gboolean set_media_size_finished;
+ gboolean install_missing_executables_finished;
+} PCData;
+
+static void
+printer_configure_async_finish (PCData *data)
+{
+ PpNewPrinterPrivate *priv = data->new_printer->priv;
+
+ if (data->set_accept_jobs_finished &&
+ data->set_enabled_finished &&
+ (data->autoconfigure_finished || priv->is_network_device) &&
+ data->set_media_size_finished &&
+ data->install_missing_executables_finished)
+ {
+ _pp_new_printer_add_async_cb (TRUE, data->new_printer);
+
+ if (data->cancellable)
+ g_object_unref (data->cancellable);
+ g_free (data);
+ }
+}
+
+static void
+pao_cb (gboolean success,
+ gpointer user_data)
+{
+ PCData *data = (PCData *) user_data;
+
+ data->set_media_size_finished = TRUE;
+ printer_configure_async_finish (data);
+}
+
+static void
+printer_set_accepting_jobs_cb (GObject *source_object,
+ GAsyncResult *res,
+ gpointer user_data)
+{
+ GVariant *output;
+ PCData *data = (PCData *) user_data;
+ GError *error = NULL;
+
+ output = g_dbus_connection_call_finish (G_DBUS_CONNECTION (source_object),
+ res,
+ &error);
+ g_object_unref (source_object);
+
+ if (output)
+ {
+ g_variant_unref (output);
+ }
+ else
+ {
+ if (error->domain != G_IO_ERROR ||
+ error->code != G_IO_ERROR_CANCELLED)
+ g_warning ("%s", error->message);
+ g_error_free (error);
+ }
+
+ data->set_accept_jobs_finished = TRUE;
+ printer_configure_async_finish (data);
+}
+
+static void
+printer_set_enabled_cb (GObject *source_object,
+ GAsyncResult *res,
+ gpointer user_data)
+{
+ GVariant *output;
+ PCData *data = (PCData *) user_data;
+ GError *error = NULL;
+
+ output = g_dbus_connection_call_finish (G_DBUS_CONNECTION (source_object),
+ res,
+ &error);
+ g_object_unref (source_object);
+
+ if (output)
+ {
+ g_variant_unref (output);
+ }
+ else
+ {
+ if (error->domain != G_IO_ERROR ||
+ error->code != G_IO_ERROR_CANCELLED)
+ g_warning ("%s", error->message);
+ g_error_free (error);
+ }
+
+ data->set_enabled_finished = TRUE;
+ printer_configure_async_finish (data);
+}
+
+typedef struct
+{
+ GList *executables;
+ GList *packages;
+ guint window_id;
+ gchar *ppd_file_name;
+ GCancellable *cancellable;
+ gpointer user_data;
+} IMEData;
+
+static void
+install_missing_executables_cb (IMEData *data)
+{
+ PCData *pc_data = (PCData *) data->user_data;
+
+ pc_data->install_missing_executables_finished = TRUE;
+ printer_configure_async_finish (pc_data);
+
+ if (data->ppd_file_name)
+ {
+ g_unlink (data->ppd_file_name);
+ g_clear_pointer (&data->ppd_file_name, g_free);
+ }
+
+ if (data->executables)
+ {
+ g_list_free_full (data->executables, g_free);
+ data->executables = NULL;
+ }
+
+ if (data->packages)
+ {
+ g_list_free_full (data->packages, g_free);
+ data->packages = NULL;
+ }
+
+ if (data->cancellable)
+ g_clear_object (&data->cancellable);
+
+ g_free (data);
+}
+
+static void
+install_package_names_cb (GObject *source_object,
+ GAsyncResult *res,
+ gpointer user_data)
+{
+ GVariant *output;
+ IMEData *data = (IMEData *) user_data;
+ GError *error = NULL;
+
+ output = g_dbus_connection_call_finish (G_DBUS_CONNECTION (source_object),
+ res,
+ &error);
+ g_object_unref (source_object);
+
+ if (output)
+ {
+ g_variant_unref (output);
+ }
+ else
+ {
+ if (error->domain != G_IO_ERROR ||
+ error->code != G_IO_ERROR_CANCELLED)
+ g_warning ("%s", error->message);
+ g_error_free (error);
+ }
+
+ install_missing_executables_cb (data);
+}
+
+
+static void
+search_files_cb (GObject *source_object,
+ GAsyncResult *res,
+ gpointer user_data)
+{
+ GVariant *output;
+ IMEData *data = (IMEData *) user_data;
+ GError *error = NULL;
+ GList *item;
+
+ output = g_dbus_connection_call_finish (G_DBUS_CONNECTION (source_object),
+ res,
+ &error);
+ if (output)
+ {
+ gboolean installed;
+ gchar *package;
+
+ g_variant_get (output,
+ "(bs)",
+ &installed,
+ &package);
+
+ if (!installed)
+ data->packages = g_list_append (data->packages, g_strdup (package));
+ g_variant_unref (output);
+ }
+ else
+ {
+ if (error->domain != G_IO_ERROR ||
+ error->code != G_IO_ERROR_CANCELLED)
+ g_warning ("%s", error->message);
+ g_error_free (error);
+ }
+
+ if (data->executables)
+ {
+ item = data->executables;
+ g_dbus_connection_call (G_DBUS_CONNECTION (source_object),
+ PACKAGE_KIT_BUS,
+ PACKAGE_KIT_PATH,
+ PACKAGE_KIT_QUERY_IFACE,
+ "SearchFile",
+ g_variant_new ("(ss)",
+ (gchar *) item->data,
+ ""),
+ G_VARIANT_TYPE ("(bs)"),
+ G_DBUS_CALL_FLAGS_NONE,
+ DBUS_TIMEOUT_LONG,
+ data->cancellable,
+ search_files_cb,
+ data);
+
+ data->executables = g_list_remove_link (data->executables, item);
+ g_list_free_full (item, g_free);
+ }
+ else
+ {
+ GVariantBuilder array_builder;
+ GList *pkg_iter;
+
+ data->packages = g_list_sort (data->packages, (GCompareFunc) g_strcmp0);
+ data->packages = glist_uniq (data->packages);
+
+ if (data->packages)
+ {
+ g_variant_builder_init (&array_builder, G_VARIANT_TYPE ("as"));
+
+ for (pkg_iter = data->packages; pkg_iter; pkg_iter = pkg_iter->next)
+ g_variant_builder_add (&array_builder,
+ "s",
+ (gchar *) pkg_iter->data);
+
+ g_dbus_connection_call (G_DBUS_CONNECTION (source_object),
+ PACKAGE_KIT_BUS,
+ PACKAGE_KIT_PATH,
+ PACKAGE_KIT_MODIFY_IFACE,
+ "InstallPackageNames",
+ g_variant_new ("(uass)",
+ data->window_id,
+ &array_builder,
+ "hide-finished"),
+ NULL,
+ G_DBUS_CALL_FLAGS_NONE,
+ DBUS_TIMEOUT_LONG,
+ data->cancellable,
+ install_package_names_cb,
+ data);
+
+ g_list_free_full (data->packages, g_free);
+ data->packages = NULL;
+ }
+ else
+ {
+ g_object_unref (source_object);
+ install_missing_executables_cb (data);
+ }
+ }
+}
+
+static void
+get_missing_executables_cb (GObject *source_object,
+ GAsyncResult *res,
+ gpointer user_data)
+{
+ GVariant *output;
+ IMEData *data = (IMEData *) user_data;
+ GError *error = NULL;
+ GList *executables = NULL;
+ GList *item;
+
+ output = g_dbus_connection_call_finish (G_DBUS_CONNECTION (source_object),
+ res,
+ &error);
+
+ if (output)
+ {
+ GVariant *array;
+
+ g_variant_get (output, "(@as)", &array);
+
+ if (array)
+ {
+ GVariantIter *iter;
+ GVariant *item;
+ gchar *executable;
+
+ g_variant_get (array, "as", &iter);
+ while ((item = g_variant_iter_next_value (iter)))
+ {
+ g_variant_get (item, "s", &executable);
+ executables = g_list_append (executables, executable);
+ g_variant_unref (item);
+ }
+
+ g_variant_unref (array);
+ }
+
+ g_variant_unref (output);
+ }
+ else if (error->domain == G_DBUS_ERROR &&
+ (error->code == G_DBUS_ERROR_SERVICE_UNKNOWN ||
+ error->code == G_DBUS_ERROR_UNKNOWN_METHOD))
+ {
+ g_warning ("Install system-config-printer which provides \
+DBus method \"MissingExecutables\" to find missing executables and filters.");
+ g_error_free (error);
+ }
+ else
+ {
+ if (error->domain != G_IO_ERROR ||
+ error->code != G_IO_ERROR_CANCELLED)
+ g_warning ("%s", error->message);
+ g_error_free (error);
+ }
+
+ executables = g_list_sort (executables, (GCompareFunc) g_strcmp0);
+ executables = glist_uniq (executables);
+
+ if (executables)
+ {
+ data->executables = executables;
+
+ item = data->executables;
+ g_dbus_connection_call (g_object_ref (source_object),
+ PACKAGE_KIT_BUS,
+ PACKAGE_KIT_PATH,
+ PACKAGE_KIT_QUERY_IFACE,
+ "SearchFile",
+ g_variant_new ("(ss)",
+ (gchar *) item->data,
+ ""),
+ G_VARIANT_TYPE ("(bs)"),
+ G_DBUS_CALL_FLAGS_NONE,
+ DBUS_TIMEOUT_LONG,
+ data->cancellable,
+ search_files_cb,
+ data);
+
+ data->executables = g_list_remove_link (data->executables, item);
+ g_list_free_full (item, g_free);
+ }
+ else
+ {
+ g_object_unref (source_object);
+ install_missing_executables_cb (data);
+ }
+
+ if (data->ppd_file_name)
+ {
+ g_unlink (data->ppd_file_name);
+ g_clear_pointer (&data->ppd_file_name, g_free);
+ }
+}
+
+static void
+printer_get_ppd_cb (const gchar *ppd_filename,
+ gpointer user_data)
+{
+ GDBusConnection *bus;
+ IMEData *data = (IMEData *) user_data;
+ GError *error = NULL;
+
+ data->ppd_file_name = g_strdup (ppd_filename);
+ if (data->ppd_file_name)
+ {
+ bus = g_bus_get_sync (G_BUS_TYPE_SESSION, NULL, &error);
+ if (!bus)
+ {
+ g_warning ("%s", error->message);
+ g_error_free (error);
+ }
+ else
+ {
+ g_dbus_connection_call (bus,
+ SCP_BUS,
+ SCP_PATH,
+ SCP_IFACE,
+ "MissingExecutables",
+ g_variant_new ("(s)", data->ppd_file_name),
+ G_VARIANT_TYPE ("(as)"),
+ G_DBUS_CALL_FLAGS_NONE,
+ DBUS_TIMEOUT,
+ data->cancellable,
+ get_missing_executables_cb,
+ data);
+ return;
+ }
+ }
+
+ install_missing_executables_cb (data);
+}
+
+static void
+pp_maintenance_command_execute_cb (GObject *source_object,
+ GAsyncResult *res,
+ gpointer user_data)
+{
+ PpMaintenanceCommand *command = (PpMaintenanceCommand *) source_object;
+ GError *error = NULL;
+ PCData *data;
+ gboolean result;
+
+ result = pp_maintenance_command_execute_finish (command, res, &error);
+ g_object_unref (source_object);
+
+ if (result)
+ {
+ data = (PCData *) user_data;
+
+ data->autoconfigure_finished = TRUE;
+ printer_configure_async_finish (data);
+ }
+ else
+ {
+ if (error->domain != G_IO_ERROR ||
+ error->code != G_IO_ERROR_CANCELLED)
+ {
+ data = (PCData *) user_data;
+
+ g_warning ("%s", error->message);
+
+ data->autoconfigure_finished = TRUE;
+ printer_configure_async_finish (data);
+ }
+
+ g_error_free (error);
+ }
+}
+
+static void
+printer_configure_async (PpNewPrinter *new_printer)
+{
+ PpNewPrinterPrivate *priv = new_printer->priv;
+ GDBusConnection *bus;
+ PCData *data;
+ IMEData *ime_data;
+ gchar **values;
+ GError *error = NULL;
+
+ data = g_new0 (PCData, 1);
+ data->new_printer = new_printer;
+ data->set_accept_jobs_finished = FALSE;
+ data->set_enabled_finished = FALSE;
+ data->autoconfigure_finished = FALSE;
+ data->set_media_size_finished = FALSE;
+ data->install_missing_executables_finished = FALSE;
+
+ /* Enable printer and make it accept jobs */
+ if (priv->name)
+ {
+ bus = g_bus_get_sync (G_BUS_TYPE_SYSTEM, NULL, &error);
+ if (bus)
+ {
+ g_dbus_connection_call (bus,
+ MECHANISM_BUS,
+ "/",
+ MECHANISM_BUS,
+ "PrinterSetAcceptJobs",
+ g_variant_new ("(sbs)",
+ priv->name,
+ TRUE,
+ ""),
+ G_VARIANT_TYPE ("(s)"),
+ G_DBUS_CALL_FLAGS_NONE,
+ -1,
+ NULL,
+ printer_set_accepting_jobs_cb,
+ data);
+
+ g_dbus_connection_call (g_object_ref (bus),
+ MECHANISM_BUS,
+ "/",
+ MECHANISM_BUS,
+ "PrinterSetEnabled",
+ g_variant_new ("(sb)",
+ priv->name,
+ TRUE),
+ G_VARIANT_TYPE ("(s)"),
+ G_DBUS_CALL_FLAGS_NONE,
+ -1,
+ NULL,
+ printer_set_enabled_cb,
+ data);
+ }
+ else
+ {
+ g_warning ("Failed to get system bus: %s", error->message);
+ g_error_free (error);
+ data->set_accept_jobs_finished = TRUE;
+ data->set_enabled_finished = TRUE;
+ }
+ }
+ else
+ {
+ data->set_accept_jobs_finished = TRUE;
+ data->set_enabled_finished = TRUE;
+ }
+
+ /* Run autoconfiguration of printer */
+ if (!priv->is_network_device)
+ {
+ PpMaintenanceCommand *command;
+ command = pp_maintenance_command_new (priv->name,
+ "autoconfigure",
+ /* Translators: Name of job which makes printer to autoconfigure itself */
+ _("Automatic configuration"));
+
+ pp_maintenance_command_execute_async (command,
+ NULL,
+ pp_maintenance_command_execute_cb,
+ data);
+ }
+
+ /* Set media size for printer */
+ values = g_new0 (gchar *, 2);
+ values[0] = g_strdup (get_paper_size_from_locale ());
+
+ printer_add_option_async (priv->name, "media", values, TRUE, NULL, pao_cb, data);
+
+ g_strfreev (values);
+
+ /* Install missing executables for printer */
+ ime_data = g_new0 (IMEData, 1);
+ ime_data->window_id = priv->window_id;
+ if (data->cancellable)
+ ime_data->cancellable = g_object_ref (data->cancellable);
+ ime_data->user_data = data;
+
+ printer_get_ppd_async (priv->name,
+ NULL,
+ 0,
+ printer_get_ppd_cb,
+ ime_data);
+}
+
+static void
+_pp_new_printer_add_async (GSimpleAsyncResult *res,
+ GObject *object,
+ GCancellable *cancellable)
+{
+ PpNewPrinter *printer = PP_NEW_PRINTER (object);
+ PpNewPrinterPrivate *priv = printer->priv;
+
+ priv->res = g_object_ref (res);
+ priv->cancellable = g_object_ref (cancellable);
+
+ if (priv->ppd_name || priv->ppd_file_name)
+ {
+ /* We have everything we need */
+ printer_add_real_async (printer);
+ }
+ else if (priv->device_id)
+ {
+ GDBusConnection *bus;
+ GError *error = NULL;
+
+ /* Try whether CUPS has a driver for the new printer */
+ bus = g_bus_get_sync (G_BUS_TYPE_SESSION, NULL, &error);
+ if (bus)
+ {
+ g_dbus_connection_call (bus,
+ SCP_BUS,
+ SCP_PATH,
+ SCP_IFACE,
+ "GetBestDrivers",
+ g_variant_new ("(sss)",
+ priv->device_id,
+ priv->make_and_model ? priv->make_and_model : "",
+ priv->device_uri ? priv->device_uri : ""),
+ G_VARIANT_TYPE ("(a(ss))"),
+ G_DBUS_CALL_FLAGS_NONE,
+ DBUS_TIMEOUT_LONG,
+ cancellable,
+ printer_add_async_scb,
+ printer);
+ }
+ else
+ {
+ g_warning ("Failed to get system bus: %s", error->message);
+ g_error_free (error);
+ _pp_new_printer_add_async_cb (FALSE, printer);
+ }
+ }
+ else if (priv->original_name && priv->host_name)
+ {
+ /* Try to get PPD from remote CUPS */
+ printer_get_ppd_async (priv->original_name,
+ priv->host_name,
+ priv->host_port,
+ printer_add_async_scb4,
+ printer);
+ }
+ else
+ {
+ _pp_new_printer_add_async_cb (FALSE, printer);
+ }
+}
+
+void
+pp_new_printer_add_async (PpNewPrinter *printer,
+ GCancellable *cancellable,
+ GAsyncReadyCallback callback,
+ gpointer user_data)
+{
+ GSimpleAsyncResult *res;
+
+ res = g_simple_async_result_new (G_OBJECT (printer), callback, user_data, pp_new_printer_add_async);
+
+ g_simple_async_result_set_check_cancellable (res, cancellable);
+ _pp_new_printer_add_async (res, G_OBJECT (printer), cancellable);
+
+ g_object_unref (res);
+}
+
+gboolean
+pp_new_printer_add_finish (PpNewPrinter *printer,
+ GAsyncResult *res,
+ GError **error)
+{
+ GSimpleAsyncResult *simple = G_SIMPLE_ASYNC_RESULT (res);
+
+ g_warn_if_fail (g_simple_async_result_get_source_tag (simple) == pp_new_printer_add_async);
+
+ if (g_simple_async_result_propagate_error (simple, error))
+ return FALSE;
+
+ return g_simple_async_result_get_op_res_gboolean (simple);
+}
diff --git a/panels/printers/pp-new-printer.h b/panels/printers/pp-new-printer.h
new file mode 100644
index 0000000..2519cb9
--- /dev/null
+++ b/panels/printers/pp-new-printer.h
@@ -0,0 +1,66 @@
+/* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 8 -*-
+ *
+ * Copyright 2012 Red Hat, Inc,
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+ *
+ * Author: Marek Kasik <mkasik redhat com>
+ */
+
+#ifndef __PP_NEW_PRINTER_H__
+#define __PP_NEW_PRINTER_H__
+
+#include <glib-object.h>
+#include <gio/gio.h>
+
+G_BEGIN_DECLS
+
+#define PP_TYPE_NEW_PRINTER (pp_new_printer_get_type ())
+#define PP_NEW_PRINTER(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), PP_TYPE_NEW_PRINTER, PpNewPrinter))
+#define PP_NEW_PRINTER_CLASS(k) (G_TYPE_CHECK_CLASS_CAST((k), PP_TYPE_NEW_PRINTER, PpNewPrinterClass))
+#define PP_IS_NEW_PRINTER(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), PP_TYPE_NEW_PRINTER))
+#define PP_IS_NEW_PRINTER_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), PP_TYPE_NEW_PRINTER))
+#define PP_NEW_PRINTER_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), PP_TYPE_NEW_PRINTER, PpNewPrinterClass))
+
+typedef struct _PpNewPrinter PpNewPrinter;
+typedef struct _PpNewPrinterClass PpNewPrinterClass;
+typedef struct _PpNewPrinterPrivate PpNewPrinterPrivate;
+
+struct _PpNewPrinter
+{
+ GObject parent_instance;
+ PpNewPrinterPrivate *priv;
+};
+
+struct _PpNewPrinterClass
+{
+ GObjectClass parent_class;
+};
+
+GType pp_new_printer_get_type (void) G_GNUC_CONST;
+PpNewPrinter *pp_new_printer_new (void);
+
+void pp_new_printer_add_async (PpNewPrinter *host,
+ GCancellable *cancellable,
+ GAsyncReadyCallback callback,
+ gpointer user_data);
+
+gboolean pp_new_printer_add_finish (PpNewPrinter *host,
+ GAsyncResult *result,
+ GError **error);
+
+G_END_DECLS
+
+#endif /* __PP_NEW_PRINTER_H__ */
[
Date Prev][
Date Next] [
Thread Prev][
Thread Next]
[
Thread Index]
[
Date Index]
[
Author Index]
