Adding upstream version 1:43.6.upstream/1%43.6upstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

51 files changed, 19020 insertions, 0 deletions

diff --git a/panels/printers/cc-printers-panel.c b/panels/printers/cc-printers-panel.c
new file mode 100644
index 0000000..34774a7
--- /dev/null
+++ b/panels/printers/cc-printers-panel.c
@@ -0,0 +1,1340 @@
+/*
+ * Copyright (C) 2010 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 2 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, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#include <config.h>
+
+#include "shell/cc-object-storage.h"
+
+#include "cc-printers-panel.h"
+#include "cc-printers-resources.h"
+#include "pp-printer.h"
+
+#include <string.h>
+#include <glib/gi18n-lib.h>
+#include <glib/gstdio.h>
+#include <polkit/polkit.h>
+#include <gdesktop-enums.h>
+
+#include <cups/cups.h>
+#include <cups/ppd.h>
+
+#include <math.h>
+
+#include "pp-new-printer-dialog.h"
+#include "pp-utils.h"
+#include "pp-cups.h"
+#include "pp-printer-entry.h"
+#include "pp-job.h"
+#include "pp-new-printer.h"
+
+#include "cc-permission-infobar.h"
+#include "cc-util.h"
+
+#define JOB_DEFAULT_PRIORITY  50
+#define RENEW_INTERVAL        500
+#define SUBSCRIPTION_DURATION 600
+
+#define CUPS_DBUS_NAME      "org.cups.cupsd.Notifier"
+#define CUPS_DBUS_PATH      "/org/cups/cupsd/Notifier"
+#define CUPS_DBUS_INTERFACE "org.cups.cupsd.Notifier"
+
+#define CUPS_STATUS_CHECK_INTERVAL 5
+
+#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
+#define ippGetStatusCode(ipp) ipp->request.status.status_code
+#define ippGetString(attr, element, language) attr->values[element].string.text
+#endif
+
+struct _CcPrintersPanel
+{
+  CcPanel parent_instance;
+
+  GtkBuilder *builder;
+
+  PpCups *cups;
+
+  cups_dest_t *dests;
+  int num_dests;
+
+  GPermission *permission;
+  gboolean is_authorized;
+
+  GSettings *lockdown_settings;
+  CcPermissionInfobar *permission_infobar;
+
+  PpNewPrinterDialog   *pp_new_printer_dialog;
+
+  GDBusProxy      *cups_proxy;
+  GDBusConnection *cups_bus_connection;
+  gint             subscription_id;
+  guint            subscription_renewal_id;
+  guint            cups_status_check_id;
+  guint            dbus_subscription_id;
+  guint            remove_printer_timeout_id;
+
+  GtkRevealer  *notification;
+  PPDList      *all_ppds_list;
+
+  gchar    *new_printer_name;
+
+  gchar    *renamed_printer_name;
+  gchar    *old_printer_name;
+  gchar    *deleted_printer_name;
+  GList    *deleted_printers;
+  GObject  *reference;
+
+  GHashTable *printer_entries;
+  gboolean    entries_filled;
+  GVariant   *action;
+
+  GtkSizeGroup *size_group;
+};
+
+CC_PANEL_REGISTER (CcPrintersPanel, cc_printers_panel)
+
+typedef struct
+{
+  gchar        *printer_name;
+  GCancellable *cancellable;
+} SetPPDItem;
+
+enum {
+  PROP_0,
+  PROP_PARAMETERS
+};
+
+static void actualize_printers_list (CcPrintersPanel *self);
+static void update_sensitivity (gpointer user_data);
+static void detach_from_cups_notifier (gpointer data);
+static void free_dests (CcPrintersPanel *self);
+static void set_current_page (GObject      *source_object,
+                              GAsyncResult *result,
+                              gpointer      user_data);
+
+static void
+execute_action (CcPrintersPanel *self,
+                GVariant        *action)
+{
+  PpPrinterEntry         *printer_entry;
+  const gchar            *action_name;
+  const gchar            *printer_name;
+  gint                    count;
+
+  count = g_variant_n_children (action);
+  if (count == 2)
+    {
+      g_autoptr(GVariant) action_variant = NULL;
+
+      g_variant_get_child (action, 0, "v", &action_variant);
+      action_name = g_variant_get_string (action_variant, NULL);
+
+      /* authenticate-jobs printer-name */
+      if (g_strcmp0 (action_name, "authenticate-jobs") == 0)
+        {
+          g_autoptr(GVariant) variant = NULL;
+
+          g_variant_get_child (action, 1, "v", &variant);
+          printer_name = g_variant_get_string (variant, NULL);
+
+          printer_entry = PP_PRINTER_ENTRY (g_hash_table_lookup (self->printer_entries, printer_name));
+          if (printer_entry != NULL)
+            pp_printer_entry_authenticate_jobs (printer_entry);
+          else
+            g_warning ("Could not find printer \"%s\"!", printer_name);
+        }
+      /* show-jobs printer-name */
+      else if (g_strcmp0 (action_name, "show-jobs") == 0)
+        {
+          g_autoptr(GVariant) variant = NULL;
+
+          g_variant_get_child (action, 1, "v", &variant);
+          printer_name = g_variant_get_string (variant, NULL);
+
+          printer_entry = PP_PRINTER_ENTRY (g_hash_table_lookup (self->printer_entries, printer_name));
+          if (printer_entry != NULL)
+            pp_printer_entry_show_jobs_dialog (printer_entry);
+          else
+            g_warning ("Could not find printer \"%s\"!", printer_name);
+        }
+    }
+}
+
+static void
+cc_printers_panel_get_property (GObject    *object,
+                               guint       property_id,
+                               GValue     *value,
+                               GParamSpec *pspec)
+{
+  switch (property_id)
+    {
+      default:
+        G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
+    }
+}
+
+static void
+cc_printers_panel_set_property (GObject      *object,
+                                guint         property_id,
+                                const GValue *value,
+                                GParamSpec   *pspec)
+{
+  CcPrintersPanel        *self = CC_PRINTERS_PANEL (object);
+  GVariant               *parameters;
+
+  switch (property_id)
+    {
+      case PROP_PARAMETERS:
+        parameters = g_value_get_variant (value);
+        if (parameters != NULL && g_variant_n_children (parameters) > 0)
+          {
+            if (self->entries_filled)
+              {
+                execute_action (CC_PRINTERS_PANEL (object), parameters);
+              }
+            else
+              {
+                if (self->action != NULL)
+                  g_variant_unref (self->action);
+                self->action = g_variant_ref (parameters);
+              }
+          }
+        break;
+
+      default:
+        G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
+    }
+}
+
+static void
+cc_printers_panel_constructed (GObject *object)
+{
+  CcPrintersPanel *self = CC_PRINTERS_PANEL (object);
+  GtkWidget *widget;
+  CcShell *shell;
+
+  G_OBJECT_CLASS (cc_printers_panel_parent_class)->constructed (object);
+
+  shell = cc_panel_get_shell (CC_PANEL (self));
+
+  widget = (GtkWidget*)
+    gtk_builder_get_object (self->builder, "search-bar");
+  gtk_search_bar_set_key_capture_widget (GTK_SEARCH_BAR (widget),
+                                         GTK_WIDGET (shell));
+}
+
+static void
+printer_removed_cb (GObject      *source_object,
+                    GAsyncResult *result,
+                    gpointer      user_data)
+{
+  PpPrinter *printer = PP_PRINTER (source_object);
+  g_autoptr(GError) error = NULL;
+
+  pp_printer_delete_finish (printer, result, &error);
+
+  if (user_data != NULL)
+    {
+      g_autoptr(GObject) reference = G_OBJECT (user_data);
+
+      if (g_object_get_data (reference, "self") != NULL)
+        {
+          CcPrintersPanel *self = CC_PRINTERS_PANEL (g_object_get_data (reference, "self"));
+          GList           *iter;
+
+          for (iter = self->deleted_printers; iter != NULL; iter = iter->next)
+            {
+              if (g_strcmp0 (iter->data, pp_printer_get_name (printer)) == 0)
+                {
+                  g_free (iter->data);
+                  self->deleted_printers = g_list_delete_link (self->deleted_printers, iter);
+                  break;
+                }
+            }
+        }
+    }
+
+  if (error != NULL)
+    g_warning ("Printer could not be deleted: %s", error->message);
+}
+
+static void
+cc_printers_panel_dispose (GObject *object)
+{
+  CcPrintersPanel *self = CC_PRINTERS_PANEL (object);
+
+  detach_from_cups_notifier (CC_PRINTERS_PANEL (object));
+
+  if (self->deleted_printer_name != NULL)
+    {
+      g_autoptr(PpPrinter) printer = pp_printer_new (self->deleted_printer_name);
+      pp_printer_delete_async (printer,
+                               NULL,
+                               printer_removed_cb,
+                               NULL);
+    }
+
+  g_clear_object (&self->cups);
+  g_clear_pointer (&self->new_printer_name, g_free);
+  g_clear_pointer (&self->renamed_printer_name, g_free);
+  g_clear_pointer (&self->old_printer_name, g_free);
+  g_clear_object (&self->builder);
+  g_clear_object (&self->lockdown_settings);
+  g_clear_object (&self->permission);
+  g_clear_handle_id (&self->cups_status_check_id, g_source_remove);
+  g_clear_handle_id (&self->remove_printer_timeout_id, g_source_remove);
+  g_clear_pointer (&self->deleted_printer_name, g_free);
+  g_clear_pointer (&self->action, g_variant_unref);
+  g_clear_pointer (&self->printer_entries, g_hash_table_destroy);
+  g_clear_pointer (&self->all_ppds_list, ppd_list_free);
+  free_dests (self);
+  g_list_free_full (self->deleted_printers, g_free);
+  self->deleted_printers = NULL;
+  if (self->reference != NULL)
+    g_object_set_data (self->reference, "self", NULL);
+  g_clear_object (&self->reference);
+
+  G_OBJECT_CLASS (cc_printers_panel_parent_class)->dispose (object);
+}
+
+static const char *
+cc_printers_panel_get_help_uri (CcPanel *panel)
+{
+  return "help:gnome-help/printing";
+}
+
+static void
+cc_printers_panel_class_init (CcPrintersPanelClass *klass)
+{
+  GObjectClass *object_class = G_OBJECT_CLASS (klass);
+  CcPanelClass *panel_class = CC_PANEL_CLASS (klass);
+
+  object_class->get_property = cc_printers_panel_get_property;
+  object_class->set_property = cc_printers_panel_set_property;
+  object_class->constructed = cc_printers_panel_constructed;
+  object_class->dispose = cc_printers_panel_dispose;
+
+  panel_class->get_help_uri = cc_printers_panel_get_help_uri;
+
+  g_object_class_override_property (object_class, PROP_PARAMETERS, "parameters");
+}
+
+static void
+on_get_job_attributes_cb (GObject      *source_object,
+                          GAsyncResult *res,
+                          gpointer      user_data)
+{
+  CcPrintersPanel        *self = (CcPrintersPanel*) user_data;
+  const gchar            *job_originating_user_name;
+  const gchar            *job_printer_uri;
+  g_autoptr(GVariant)     attributes = NULL;
+  g_autoptr(GError)       error = NULL;
+
+  attributes = pp_job_get_attributes_finish (PP_JOB (source_object), res, &error);
+
+  if (attributes != NULL)
+    {
+      g_autoptr(GVariant) username = NULL;
+
+      if ((username = g_variant_lookup_value (attributes, "job-originating-user-name", G_VARIANT_TYPE ("as"))) != NULL)
+        {
+          g_autoptr(GVariant) printer_uri = NULL;
+
+          if ((printer_uri = g_variant_lookup_value (attributes, "job-printer-uri", G_VARIANT_TYPE ("as"))) != NULL)
+            {
+              job_originating_user_name = g_variant_get_string (g_variant_get_child_value (username, 0), NULL);
+              job_printer_uri = g_variant_get_string (g_variant_get_child_value (printer_uri, 0), NULL);
+
+              if (job_originating_user_name != NULL && job_printer_uri != NULL &&
+                  g_strcmp0 (job_originating_user_name, cupsUser ()) == 0 &&
+                  g_strrstr (job_printer_uri, "/") != 0 &&
+                  self->dests != NULL)
+                {
+                  PpPrinterEntry *printer_entry;
+                  gchar *printer_name;
+
+                  printer_name = g_strrstr (job_printer_uri, "/") + 1;
+                  printer_entry = PP_PRINTER_ENTRY (g_hash_table_lookup (self->printer_entries, printer_name));
+
+                  pp_printer_entry_update_jobs_count (printer_entry);
+                }
+            }
+        }
+    }
+}
+
+static void
+on_cups_notification (GDBusConnection *connection,
+                      const char      *sender_name,
+                      const char      *object_path,
+                      const char      *interface_name,
+                      const char      *signal_name,
+                      GVariant        *parameters,
+                      gpointer         user_data)
+{
+  CcPrintersPanel        *self = (CcPrintersPanel*) user_data;
+  gboolean                printer_is_accepting_jobs;
+  gchar                  *printer_name = NULL;
+  gchar                  *text = NULL;
+  gchar                  *printer_uri = NULL;
+  gchar                  *printer_state_reasons = NULL;
+  gchar                  *job_state_reasons = NULL;
+  gchar                  *job_name = NULL;
+  guint                   job_id;
+  gint                    printer_state;
+  gint                    job_state;
+  gint                    job_impressions_completed;
+  static gchar *requested_attrs[] = {
+    "job-printer-uri",
+    "job-originating-user-name",
+    NULL };
+
+  if (g_strcmp0 (signal_name, "PrinterAdded") != 0 &&
+      g_strcmp0 (signal_name, "PrinterDeleted") != 0 &&
+      g_strcmp0 (signal_name, "PrinterStateChanged") != 0 &&
+      g_strcmp0 (signal_name, "PrinterStopped") != 0 &&
+      g_strcmp0 (signal_name, "JobCreated") != 0 &&
+      g_strcmp0 (signal_name, "JobCompleted") != 0)
+    return;
+
+  if (g_variant_n_children (parameters) == 1)
+    g_variant_get (parameters, "(&s)", &text);
+ else if (g_variant_n_children (parameters) == 6)
+    {
+      g_variant_get (parameters, "(&s&s&su&sb)",
+                     &text,
+                     &printer_uri,
+                     &printer_name,
+                     &printer_state,
+                     &printer_state_reasons,
+                     &printer_is_accepting_jobs);
+    }
+  else if (g_variant_n_children (parameters) == 11)
+    {
+      g_variant_get (parameters, "(&s&s&su&sbuu&s&su)",
+                     &text,
+                     &printer_uri,
+                     &printer_name,
+                     &printer_state,
+                     &printer_state_reasons,
+                     &printer_is_accepting_jobs,
+                     &job_id,
+                     &job_state,
+                     &job_state_reasons,
+                     &job_name,
+                     &job_impressions_completed);
+    }
+
+  if (g_strcmp0 (signal_name, "PrinterAdded") == 0 ||
+      g_strcmp0 (signal_name, "PrinterDeleted") == 0 ||
+      g_strcmp0 (signal_name, "PrinterStateChanged") == 0 ||
+      g_strcmp0 (signal_name, "PrinterStopped") == 0)
+    actualize_printers_list (self);
+  else if (g_strcmp0 (signal_name, "JobCreated") == 0 ||
+           g_strcmp0 (signal_name, "JobCompleted") == 0)
+    {
+      g_autoptr(PpJob) job = NULL;
+
+      job = pp_job_new (job_id, NULL, 0, JOB_DEFAULT_PRIORITY, NULL);
+      pp_job_get_attributes_async (job,
+                                   requested_attrs,
+                                   cc_panel_get_cancellable (CC_PANEL (self)),
+                                   on_get_job_attributes_cb,
+                                   self);
+    }
+}
+
+static gchar *subscription_events[] = {
+  "printer-added",
+  "printer-deleted",
+  "printer-stopped",
+  "printer-state-changed",
+  "job-created",
+  "job-completed",
+  NULL};
+
+static void
+renew_subscription_cb (GObject      *source_object,
+           GAsyncResult *result,
+           gpointer      user_data)
+{
+  CcPrintersPanel        *self = (CcPrintersPanel*) user_data;
+  gint                    subscription_id;
+
+  subscription_id = pp_cups_renew_subscription_finish (PP_CUPS (source_object), result);
+
+  if (subscription_id > 0)
+      self->subscription_id = subscription_id;
+}
+
+static gboolean
+renew_subscription (gpointer data)
+{
+  CcPrintersPanel        *self = (CcPrintersPanel*) data;
+
+  pp_cups_renew_subscription_async (self->cups,
+                                    self->subscription_id,
+                                    subscription_events,
+                                    SUBSCRIPTION_DURATION,
+                                    cc_panel_get_cancellable (CC_PANEL (self)),
+                                    renew_subscription_cb,
+                                    data);
+
+  return G_SOURCE_CONTINUE;
+}
+
+static void
+attach_to_cups_notifier_cb (GObject      *source_object,
+                            GAsyncResult *result,
+                            gpointer      user_data)
+{
+  CcPrintersPanel        *self = (CcPrintersPanel*) user_data;
+  g_autoptr(GError)       error = NULL;
+  gint                    subscription_id;
+
+  subscription_id = pp_cups_renew_subscription_finish (PP_CUPS (source_object), result);
+
+  if (subscription_id > 0)
+    {
+      self->subscription_id = subscription_id;
+
+      self->subscription_renewal_id =
+        g_timeout_add_seconds (RENEW_INTERVAL, renew_subscription, self);
+
+      self->cups_proxy = cc_object_storage_create_dbus_proxy_sync (G_BUS_TYPE_SYSTEM,
+                                                                   G_DBUS_PROXY_FLAGS_NONE,
+                                                                   CUPS_DBUS_NAME,
+                                                                   CUPS_DBUS_PATH,
+                                                                   CUPS_DBUS_INTERFACE,
+                                                                   NULL,
+                                                                   &error);
+
+      if (!self->cups_proxy)
+        {
+          g_warning ("%s", error->message);
+          return;
+        }
+
+      self->cups_bus_connection = g_dbus_proxy_get_connection (self->cups_proxy);
+
+      self->dbus_subscription_id =
+        g_dbus_connection_signal_subscribe (self->cups_bus_connection,
+                                            NULL,
+                                            CUPS_DBUS_INTERFACE,
+                                            NULL,
+                                            CUPS_DBUS_PATH,
+                                            NULL,
+                                            0,
+                                            on_cups_notification,
+                                            self,
+                                            NULL);
+    }
+}
+
+static void
+attach_to_cups_notifier (gpointer data)
+{
+  CcPrintersPanel        *self = (CcPrintersPanel*) data;
+
+  pp_cups_renew_subscription_async (self->cups,
+                                    self->subscription_id,
+                                    subscription_events,
+                                    SUBSCRIPTION_DURATION,
+                                    cc_panel_get_cancellable (CC_PANEL (self)),
+                                    attach_to_cups_notifier_cb,
+                                    data);
+}
+
+static void
+subscription_cancel_cb (GObject      *source_object,
+                        GAsyncResult *result,
+                        gpointer      user_data)
+{
+  pp_cups_cancel_subscription_finish (PP_CUPS (source_object), result);
+}
+
+static void
+detach_from_cups_notifier (gpointer data)
+{
+  CcPrintersPanel        *self = (CcPrintersPanel*) data;
+
+  if (self->dbus_subscription_id != 0) {
+    g_dbus_connection_signal_unsubscribe (self->cups_bus_connection,
+                                          self->dbus_subscription_id);
+    self->dbus_subscription_id = 0;
+  }
+
+  pp_cups_cancel_subscription_async (self->cups,
+                                     self->subscription_id,
+                                     subscription_cancel_cb,
+                                     NULL);
+
+  self->subscription_id = 0;
+
+  if (self->subscription_renewal_id != 0) {
+    g_source_remove (self->subscription_renewal_id);
+    self->subscription_renewal_id = 0;
+  }
+
+  g_clear_object (&self->cups_proxy);
+}
+
+static void
+free_dests (CcPrintersPanel *self)
+{
+  if (self->num_dests > 0)
+    {
+      cupsFreeDests (self->num_dests, self->dests);
+    }
+  self->dests = NULL;
+  self->num_dests = 0;
+}
+
+static void
+on_printer_deletion_undone (CcPrintersPanel *self)
+{
+  GtkWidget *widget;
+
+  gtk_revealer_set_reveal_child (self->notification, FALSE);
+
+  g_clear_pointer (&self->deleted_printer_name, g_free);
+
+  widget = (GtkWidget*) gtk_builder_get_object (self->builder, "content");
+  gtk_list_box_invalidate_filter (GTK_LIST_BOX (widget));
+
+  g_clear_handle_id (&self->remove_printer_timeout_id, g_source_remove);
+
+  if (self->num_dests > 0)
+    {
+      widget = (GtkWidget *) gtk_builder_get_object (self->builder, "main-vbox");
+      gtk_stack_set_visible_child_name (GTK_STACK (widget), "printers-list");
+    }
+}
+
+static void
+on_notification_dismissed (CcPrintersPanel *self)
+{
+  g_clear_handle_id (&self->remove_printer_timeout_id, g_source_remove);
+
+  if (self->deleted_printer_name != NULL)
+    {
+      g_autoptr(PpPrinter) printer = NULL;
+
+      printer = pp_printer_new (self->deleted_printer_name);
+      /* The reference tells to the callback whether
+         printers panel was already destroyed so
+         it knows whether it can access the list
+         of deleted printers in it (see below).
+       */
+      pp_printer_delete_async (printer,
+                               NULL,
+                               printer_removed_cb,
+                               g_object_ref (self->reference));
+
+      /* List of printers which were recently deleted but are still available
+         in CUPS due to async nature of the method (e.g. quick deletion
+         of several printers).
+       */
+      self->deleted_printers = g_list_prepend (self->deleted_printers, self->deleted_printer_name);
+      self->deleted_printer_name = NULL;
+    }
+
+  gtk_revealer_set_reveal_child (self->notification, FALSE);
+}
+
+static gboolean
+on_remove_printer_timeout (CcPrintersPanel *self)
+{
+  self->remove_printer_timeout_id = 0;
+
+  on_notification_dismissed (self);
+
+  return G_SOURCE_REMOVE;
+}
+
+static void
+on_printer_deleted (CcPrintersPanel *self,
+                    PpPrinterEntry  *printer_entry)
+{
+  GtkLabel         *label;
+  g_autofree gchar *notification_message = NULL;
+  GtkWidget        *widget;
+
+  on_notification_dismissed (self);
+
+  /* Translators: %s is the printer name */
+  notification_message = g_strdup_printf (_("Printer “%s” has been deleted"),
+                                          pp_printer_entry_get_name (printer_entry));
+  label = (GtkLabel*)
+    gtk_builder_get_object (self->builder, "notification-label");
+  gtk_label_set_label (label, notification_message);
+
+  self->deleted_printer_name = g_strdup (pp_printer_entry_get_name (printer_entry));
+
+  widget = (GtkWidget*) gtk_builder_get_object (self->builder, "content");
+  gtk_list_box_invalidate_filter (GTK_LIST_BOX (widget));
+
+  gtk_revealer_set_reveal_child (self->notification, TRUE);
+
+  self->remove_printer_timeout_id = g_timeout_add_seconds (10, G_SOURCE_FUNC (on_remove_printer_timeout), self);
+
+  if (self->num_dests == 1 + g_list_length (self->deleted_printers))
+    pp_cups_connection_test_async (self->cups, NULL, set_current_page, self);
+}
+
+static void
+on_printer_renamed (CcPrintersPanel *self,
+                    gchar           *new_name,
+                    PpPrinterEntry  *printer_entry)
+{
+  self->old_printer_name = g_strdup (pp_printer_entry_get_name (printer_entry));
+  self->renamed_printer_name = g_strdup (new_name);
+}
+
+static void
+on_printer_changed (CcPrintersPanel *self)
+{
+  actualize_printers_list (self);
+}
+
+static void
+add_printer_entry (CcPrintersPanel *self,
+                   cups_dest_t      printer)
+{
+  PpPrinterEntry         *printer_entry;
+  GtkWidget              *content;
+  GSList                 *widgets, *l;
+
+  content = (GtkWidget*) gtk_builder_get_object (self->builder, "content");
+
+  printer_entry = pp_printer_entry_new (printer, self->is_authorized);
+  gtk_widget_show (GTK_WIDGET (printer_entry));
+
+  widgets = pp_printer_entry_get_size_group_widgets (printer_entry);
+  for (l = widgets; l != NULL; l = l->next)
+    gtk_size_group_add_widget (self->size_group, GTK_WIDGET (l->data));
+  g_slist_free (widgets);
+
+  g_signal_connect_object (printer_entry,
+                           "printer-changed",
+                           G_CALLBACK (on_printer_changed),
+                           self,
+                           G_CONNECT_SWAPPED);
+  g_signal_connect_object (printer_entry,
+                           "printer-delete",
+                           G_CALLBACK (on_printer_deleted),
+                           self,
+                           G_CONNECT_SWAPPED);
+  g_signal_connect_object (printer_entry,
+                           "printer-renamed",
+                           G_CALLBACK (on_printer_renamed),
+                           self,
+                           G_CONNECT_SWAPPED);
+
+  gtk_list_box_insert (GTK_LIST_BOX (content), GTK_WIDGET (printer_entry), -1);
+
+  g_hash_table_insert (self->printer_entries, g_strdup (printer.name), printer_entry);
+}
+
+static void
+set_current_page (GObject      *source_object,
+                  GAsyncResult *result,
+                  gpointer      user_data)
+{
+  CcPrintersPanel        *self = (CcPrintersPanel *) user_data;
+  GtkWidget              *widget;
+  gboolean               success;
+
+  success = pp_cups_connection_test_finish (PP_CUPS (source_object), result, NULL);
+
+  widget = (GtkWidget*) gtk_builder_get_object (self->builder, "main-vbox");
+  if (success)
+    gtk_stack_set_visible_child_name (GTK_STACK (widget), "empty-state");
+  else
+    gtk_stack_set_visible_child_name (GTK_STACK (widget), "no-cups-page");
+
+  update_sensitivity (user_data);
+}
+
+static gboolean
+remove_nonexisting_entry (CcPrintersPanel *self,
+                          PpPrinterEntry  *entry)
+{
+  gboolean exists = FALSE;
+  gint     i;
+
+  for (i = 0; i < self->num_dests; i++)
+    {
+      if (g_strcmp0 (self->dests[i].name, pp_printer_entry_get_name (entry)) == 0)
+        {
+          exists = TRUE;
+          break;
+        }
+    }
+
+  if (!exists)
+    g_hash_table_remove (self->printer_entries, pp_printer_entry_get_name (entry));
+
+  return !exists;
+}
+
+static void
+actualize_printers_list_cb (GObject      *source_object,
+                            GAsyncResult *result,
+                            gpointer      user_data)
+{
+  CcPrintersPanel        *self = (CcPrintersPanel*) user_data;
+  GtkWidget              *widget;
+  PpCupsDests            *cups_dests;
+  GtkWidget              *child;
+  gboolean                new_printer_available = FALSE;
+  g_autoptr(GError)       error = NULL;
+  gpointer                item;
+  int                     i;
+
+  cups_dests = pp_cups_get_dests_finish (PP_CUPS (source_object), result, &error);
+
+  if (cups_dests == NULL && error != NULL)
+    {
+      if (!g_error_matches (error, G_IO_ERROR, G_IO_ERROR_CANCELLED))
+        {
+          g_warning ("Could not get dests: %s", error->message);
+        }
+
+      return;
+    }
+
+  free_dests (self);
+  self->dests = cups_dests->dests;
+  self->num_dests = cups_dests->num_of_dests;
+  g_free (cups_dests);
+
+  widget = (GtkWidget*) gtk_builder_get_object (self->builder, "main-vbox");
+  if ((self->num_dests == 0 && self->new_printer_name == NULL) ||
+      (self->num_dests == 1 + g_list_length (self->deleted_printers) &&
+       self->deleted_printer_name != NULL))
+    pp_cups_connection_test_async (PP_CUPS (source_object), NULL, set_current_page, self);
+  else
+    gtk_stack_set_visible_child_name (GTK_STACK (widget), "printers-list");
+
+  widget = (GtkWidget*) gtk_builder_get_object (self->builder, "content");
+  child = gtk_widget_get_first_child (widget);
+  while (child)
+    {
+      GtkWidget *next = gtk_widget_get_next_sibling (child);
+
+      if (remove_nonexisting_entry (self, PP_PRINTER_ENTRY (child)))
+        gtk_list_box_remove (GTK_LIST_BOX (widget), child);
+
+      child = next;
+    }
+
+  for (i = 0; i < self->num_dests; i++)
+    {
+      new_printer_available = g_strcmp0 (self->dests[i].name, self->renamed_printer_name) == 0;
+      if (new_printer_available)
+        break;
+    }
+
+  for (i = 0; i < self->num_dests; i++)
+    {
+      if (new_printer_available && g_strcmp0 (self->dests[i].name, self->old_printer_name) == 0)
+          continue;
+
+      item = g_hash_table_lookup (self->printer_entries, self->dests[i].name);
+      if (item != NULL)
+        pp_printer_entry_update (PP_PRINTER_ENTRY (item), self->dests[i], self->is_authorized);
+      else
+        add_printer_entry (self, self->dests[i]);
+    }
+
+  if (!self->entries_filled)
+    {
+      if (self->action != NULL)
+        {
+          execute_action (self, self->action);
+          g_variant_unref (self->action);
+          self->action = NULL;
+        }
+
+      self->entries_filled = TRUE;
+    }
+
+  update_sensitivity (user_data);
+
+  if (self->new_printer_name != NULL)
+    {
+      GtkScrolledWindow      *scrolled_window;
+      GtkAllocation           allocation;
+      GtkAdjustment          *adjustment;
+      GtkWidget              *printer_entry;
+
+      /* Scroll the view to show the newly added printer-entry. */
+      scrolled_window = GTK_SCROLLED_WINDOW (gtk_builder_get_object (self->builder,
+                                                                     "scrolled-window"));
+      adjustment = gtk_scrolled_window_get_vadjustment (scrolled_window);
+
+      printer_entry = GTK_WIDGET (g_hash_table_lookup (self->printer_entries,
+                                                       self->new_printer_name));
+      if (printer_entry != NULL)
+        {
+          gtk_widget_get_allocation (printer_entry, &allocation);
+          g_clear_pointer (&self->new_printer_name, g_free);
+
+          gtk_adjustment_set_value (adjustment,
+                                    allocation.y - gtk_widget_get_margin_top (printer_entry));
+        }
+    }
+}
+
+static void
+actualize_printers_list (CcPrintersPanel *self)
+{
+  pp_cups_get_dests_async (self->cups,
+                           cc_panel_get_cancellable (CC_PANEL (self)),
+                           actualize_printers_list_cb,
+                           self);
+}
+
+static void
+printer_add_async_cb (GObject      *source_object,
+                      GAsyncResult *res,
+                      gpointer      user_data)
+{
+  CcPrintersPanel  *self = (CcPrintersPanel*) user_data;
+  gboolean          success;
+  g_autoptr(GError) error = NULL;
+
+  success = pp_new_printer_add_finish (PP_NEW_PRINTER (source_object), res, &error);
+
+  if (!success)
+    {
+      if (!g_error_matches (error, G_IO_ERROR, G_IO_ERROR_CANCELLED))
+        {
+          g_warning ("%s", error->message);
+
+          GtkWidget *message_dialog;
+
+          message_dialog = gtk_message_dialog_new (NULL,
+                                                   0,
+                                                   GTK_MESSAGE_ERROR,
+                                                   GTK_BUTTONS_CLOSE,
+          /* Translators: Addition of the new printer failed. */
+                                                   _("Failed to add new printer."));
+          g_signal_connect (message_dialog,
+                            "response",
+                            G_CALLBACK (gtk_window_destroy),
+                            NULL);
+          gtk_widget_show (message_dialog);
+        }
+    }
+
+  actualize_printers_list (self);
+}
+
+static void
+new_printer_dialog_response_cb (GtkDialog *_dialog,
+                                gint       response_id,
+                                gpointer   user_data)
+{
+  CcPrintersPanel         *self = (CcPrintersPanel*) user_data;
+  PpNewPrinterDialog      *pp_new_printer_dialog =  PP_NEW_PRINTER_DIALOG (_dialog);
+  g_autoptr(PpNewPrinter)  new_printer = NULL;
+
+  if (response_id == GTK_RESPONSE_OK)
+    {
+      new_printer = pp_new_printer_dialog_get_new_printer (pp_new_printer_dialog);
+      g_object_get(G_OBJECT (new_printer), "name", &self->new_printer_name, NULL);
+
+      actualize_printers_list (self);
+
+      pp_new_printer_add_async (new_printer,
+                                cc_panel_get_cancellable (CC_PANEL (self)),
+                                printer_add_async_cb,
+                                self);
+    }
+
+  gtk_window_destroy (GTK_WINDOW (pp_new_printer_dialog));
+  self->pp_new_printer_dialog = NULL;
+}
+
+static void
+printer_add_cb (CcPrintersPanel *self)
+{
+  GtkNative *native;
+
+  native = gtk_widget_get_native (GTK_WIDGET (self));
+  self->pp_new_printer_dialog = pp_new_printer_dialog_new (self->all_ppds_list,
+                                                           new_printer_dialog_response_cb,
+                                                           self);
+
+  gtk_window_set_transient_for (GTK_WINDOW (self->pp_new_printer_dialog),
+                                            GTK_WINDOW (native));
+
+  gtk_widget_show (GTK_WIDGET (self->pp_new_printer_dialog));
+}
+
+static void
+update_sensitivity (gpointer user_data)
+{
+  CcPrintersPanel         *self = (CcPrintersPanel*) user_data;
+  const char              *cups_server = NULL;
+  GtkWidget               *widget;
+  gboolean                 local_server = TRUE;
+  gboolean                 no_cups = FALSE;
+  gboolean                 empty_state = FALSE;
+
+  self->is_authorized =
+    self->permission &&
+    g_permission_get_allowed (G_PERMISSION (self->permission)) &&
+    self->lockdown_settings &&
+    !g_settings_get_boolean (self->lockdown_settings, "disable-print-setup");
+
+  widget = (GtkWidget*) gtk_builder_get_object (self->builder, "main-vbox");
+  if (g_strcmp0 (gtk_stack_get_visible_child_name (GTK_STACK (widget)), "no-cups-page") == 0)
+    no_cups = TRUE;
+  else if (g_strcmp0 (gtk_stack_get_visible_child_name (GTK_STACK (widget)), "empty-state") == 0)
+    empty_state = TRUE;
+
+  cups_server = cupsServer ();
+  if (cups_server &&
+      g_ascii_strncasecmp (cups_server, "localhost", 9) != 0 &&
+      g_ascii_strncasecmp (cups_server, "127.0.0.1", 9) != 0 &&
+      g_ascii_strncasecmp (cups_server, "::1", 3) != 0 &&
+      cups_server[0] != '/')
+    local_server = FALSE;
+
+  widget = (GtkWidget*) gtk_builder_get_object (self->builder, "search-button");
+  gtk_widget_set_visible (widget, !no_cups);
+
+  widget = (GtkWidget*) gtk_builder_get_object (self->builder, "search-bar");
+  gtk_widget_set_visible (widget, !no_cups);
+
+  widget = (GtkWidget*) gtk_builder_get_object (self->builder, "printer-add-button");
+  gtk_widget_set_visible (widget, !empty_state);
+  gtk_widget_set_sensitive (widget, local_server && self->is_authorized && !no_cups && !self->new_printer_name);
+
+  widget = (GtkWidget*) gtk_builder_get_object (self->builder, "printer-add-button2");
+  gtk_widget_set_sensitive (widget, local_server && self->is_authorized && !no_cups && !self->new_printer_name);
+}
+
+static void
+on_permission_changed (CcPrintersPanel *self)
+{
+  actualize_printers_list (self);
+  update_sensitivity (self);
+}
+
+static void
+on_lockdown_settings_changed (CcPrintersPanel *self,
+                              const char      *key)
+{
+  if (g_str_equal (key, "disable-print-setup") == FALSE)
+    return;
+
+#if 0
+  /* FIXME */
+  gtk_widget_set_sensitive (self->lock_button,
+    !g_settings_get_boolean (self->lockdown_settings, "disable-print-setup"));
+#endif
+
+  on_permission_changed (self);
+}
+
+static void
+cups_status_check_cb (GObject      *source_object,
+                      GAsyncResult *result,
+                      gpointer      user_data)
+{
+  CcPrintersPanel        *self = (CcPrintersPanel*) user_data;
+  gboolean                success;
+
+  success = pp_cups_connection_test_finish (PP_CUPS (source_object), result, NULL);
+  if (success)
+    {
+      actualize_printers_list (self);
+      attach_to_cups_notifier (self);
+
+      g_source_remove (self->cups_status_check_id);
+      self->cups_status_check_id = 0;
+    }
+}
+
+static gboolean
+cups_status_check (gpointer user_data)
+{
+  CcPrintersPanel         *self = (CcPrintersPanel*) user_data;
+
+  pp_cups_connection_test_async (self->cups, NULL, cups_status_check_cb, self);
+
+  return self->cups_status_check_id != 0;
+}
+
+static void
+connection_test_cb (GObject      *source_object,
+                    GAsyncResult *result,
+                    gpointer      user_data)
+{
+  CcPrintersPanel        *self;
+  gboolean                success;
+  g_autoptr(GError)       error = NULL;
+
+  success = pp_cups_connection_test_finish (PP_CUPS (source_object), result, &error);
+
+  if (error != NULL)
+    {
+      if (!g_error_matches (error, G_IO_ERROR, G_IO_ERROR_CANCELLED))
+        {
+          g_warning ("Could not test connection: %s", error->message);
+        }
+
+      return;
+    }
+
+  self = CC_PRINTERS_PANEL (user_data);
+
+  if (!success)
+    {
+      self->cups_status_check_id =
+        g_timeout_add_seconds (CUPS_STATUS_CHECK_INTERVAL, cups_status_check, self);
+    }
+}
+
+static void
+get_all_ppds_async_cb (PPDList  *ppds,
+                       gpointer  user_data)
+{
+  CcPrintersPanel        *self = (CcPrintersPanel*) user_data;
+
+  self->all_ppds_list = ppd_list_copy (ppds);
+
+  if (self->pp_new_printer_dialog)
+    pp_new_printer_dialog_set_ppd_list (self->pp_new_printer_dialog,
+                                        self->all_ppds_list);
+}
+
+static gboolean
+filter_function (GtkListBoxRow *row,
+                 gpointer       user_data)
+{
+  CcPrintersPanel        *self = (CcPrintersPanel*) user_data;
+  PpPrinterEntry         *entry = PP_PRINTER_ENTRY (row);
+  GtkWidget              *search_entry;
+  gboolean                retval;
+  g_autofree gchar       *search = NULL;
+  g_autofree gchar       *name = NULL;
+  g_autofree gchar       *location = NULL;
+  GList                  *iter;
+  const gchar            *search_text;
+
+  search_entry = (GtkWidget*)
+    gtk_builder_get_object (self->builder, "search-entry");
+  search_text = gtk_editable_get_text (GTK_EDITABLE (search_entry));
+
+  if (g_utf8_strlen (search_text, -1) == 0)
+    {
+      retval = TRUE;
+    }
+  else
+    {
+      name = cc_util_normalize_casefold_and_unaccent (pp_printer_entry_get_name (entry));
+      location = cc_util_normalize_casefold_and_unaccent (pp_printer_entry_get_location (entry));
+
+      search = cc_util_normalize_casefold_and_unaccent (search_text);
+
+      retval = strstr (name, search) != NULL;
+      if (location != NULL)
+          retval = retval || (strstr (location, search) != NULL);
+    }
+
+  if (self->deleted_printer_name != NULL &&
+      g_strcmp0 (self->deleted_printer_name, pp_printer_entry_get_name (entry)) == 0)
+    {
+      retval = FALSE;
+    }
+
+  if (self->deleted_printers != NULL)
+    {
+      for (iter = self->deleted_printers; iter != NULL; iter = iter->next)
+        {
+          if (g_strcmp0 (iter->data, pp_printer_entry_get_name (entry)) == 0)
+            {
+              retval = FALSE;
+              break;
+            }
+        }
+    }
+
+  return retval;
+}
+
+static gint
+sort_function (GtkListBoxRow *row1,
+               GtkListBoxRow *row2,
+               gpointer       user_data)
+{
+  PpPrinterEntry *entry1 = PP_PRINTER_ENTRY (row1);
+  PpPrinterEntry *entry2 = PP_PRINTER_ENTRY (row2);
+
+  if (pp_printer_entry_get_name (entry1) != NULL)
+    {
+      if (pp_printer_entry_get_name (entry2) != NULL)
+        return g_ascii_strcasecmp (pp_printer_entry_get_name (entry1), pp_printer_entry_get_name (entry2));
+      else
+        return 1;
+    }
+  else
+    {
+      if (pp_printer_entry_get_name (entry2) != NULL)
+        return -1;
+      else
+        return 0;
+    }
+}
+
+static void
+cc_printers_panel_init (CcPrintersPanel *self)
+{
+  GtkWidget              *top_widget;
+  GtkWidget              *widget;
+  g_autoptr(GError)       error = NULL;
+  const gchar            *objects[] = { "overlay", "permission-infobar", "top-right-buttons", "printer-add-button", "search-button", NULL };
+  guint                   builder_result;
+
+  g_resources_register (cc_printers_get_resource ());
+
+  /* initialize main data structure */
+  self->builder = gtk_builder_new ();
+  self->reference = g_object_new (G_TYPE_OBJECT, NULL);
+
+  self->cups = pp_cups_new ();
+
+  self->printer_entries = g_hash_table_new_full (g_str_hash,
+                                                 g_str_equal,
+                                                 g_free,
+                                                 NULL);
+
+  g_type_ensure (CC_TYPE_PERMISSION_INFOBAR);
+
+  g_object_set_data_full (self->reference, "self", self, NULL);
+
+  builder_result = gtk_builder_add_objects_from_resource (self->builder,
+                                                          "/org/gnome/control-center/printers/printers.ui",
+                                                          objects, &error);
+
+  if (builder_result == 0)
+    {
+      /* Translators: The XML file containing user interface can not be loaded */
+      g_warning (_("Could not load ui: %s"), error->message);
+      return;
+    }
+
+  self->notification = (GtkRevealer*)
+    gtk_builder_get_object (self->builder, "notification");
+
+  widget = (GtkWidget*)
+    gtk_builder_get_object (self->builder, "notification-undo-button");
+  g_signal_connect_object (widget, "clicked", G_CALLBACK (on_printer_deletion_undone), self, G_CONNECT_SWAPPED);
+
+  widget = (GtkWidget*)
+    gtk_builder_get_object (self->builder, "notification-dismiss-button");
+  g_signal_connect_object (widget, "clicked", G_CALLBACK (on_notification_dismissed), self, G_CONNECT_SWAPPED);
+
+  self->permission_infobar = (CcPermissionInfobar*)
+    gtk_builder_get_object (self->builder, "permission-infobar");
+
+  /* add the top level widget */
+  top_widget = (GtkWidget*)
+    gtk_builder_get_object (self->builder, "overlay");
+
+  /* connect signals */
+  widget = (GtkWidget*)
+    gtk_builder_get_object (self->builder, "printer-add-button");
+  g_signal_connect_object (widget, "clicked", G_CALLBACK (printer_add_cb), self, G_CONNECT_SWAPPED);
+
+  widget = (GtkWidget*)
+    gtk_builder_get_object (self->builder, "printer-add-button2");
+  g_signal_connect_object (widget, "clicked", G_CALLBACK (printer_add_cb), self, G_CONNECT_SWAPPED);
+
+  widget = (GtkWidget*)
+    gtk_builder_get_object (self->builder, "content");
+  gtk_list_box_set_filter_func (GTK_LIST_BOX (widget),
+                                filter_function,
+                                self,
+                                NULL);
+  g_signal_connect_swapped (gtk_builder_get_object (self->builder, "search-entry"),
+                            "search-changed",
+                            G_CALLBACK (gtk_list_box_invalidate_filter),
+                            widget);
+  gtk_list_box_set_sort_func (GTK_LIST_BOX (widget),
+                              sort_function,
+                              NULL,
+                              NULL);
+
+  self->lockdown_settings = g_settings_new ("org.gnome.desktop.lockdown");
+  if (self->lockdown_settings)
+    g_signal_connect_object (self->lockdown_settings,
+                             "changed",
+                             G_CALLBACK (on_lockdown_settings_changed),
+                             self,
+                             G_CONNECT_SWAPPED | G_CONNECT_AFTER);
+
+  /* Add unlock button */
+  self->permission = (GPermission *)polkit_permission_new_sync (
+    "org.opensuse.cupspkhelper.mechanism.all-edit", NULL, NULL, NULL);
+  if (self->permission != NULL)
+    {
+      g_signal_connect_object (self->permission,
+                               "notify",
+                               G_CALLBACK (on_permission_changed),
+                               self,
+                               G_CONNECT_SWAPPED | G_CONNECT_AFTER);
+
+      cc_permission_infobar_set_permission (self->permission_infobar,
+                                            self->permission);
+      cc_permission_infobar_set_title (self->permission_infobar,
+				       _("Unlock to Add Printers and Change Settings"));
+
+      on_permission_changed (self);
+    }
+  else
+    g_warning ("Your system does not have the cups-pk-helper's policy \
+\"org.opensuse.cupspkhelper.mechanism.all-edit\" installed. \
+Please check your installation");
+
+  self->size_group = gtk_size_group_new (GTK_SIZE_GROUP_HORIZONTAL);
+
+  actualize_printers_list (self);
+  attach_to_cups_notifier (self);
+
+  get_all_ppds_async (cc_panel_get_cancellable (CC_PANEL (self)),
+                      get_all_ppds_async_cb,
+                      self);
+
+  pp_cups_connection_test_async (self->cups, cc_panel_get_cancellable (CC_PANEL (self)), connection_test_cb, self);
+  cc_panel_set_content (CC_PANEL (self), top_widget);
+
+  widget = (GtkWidget*)
+    gtk_builder_get_object (self->builder, "top-right-buttons");
+  adw_header_bar_pack_end (ADW_HEADER_BAR (cc_panel_get_titlebar (CC_PANEL (self))),
+                           widget);
+}
diff --git a/panels/printers/cc-printers-panel.h b/panels/printers/cc-printers-panel.h
new file mode 100644
index 0000000..18e93a4
--- /dev/null
+++ b/panels/printers/cc-printers-panel.h
@@ -0,0 +1,28 @@
+/*
+ * Copyright (C) 2010 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 2 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, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#pragma once
+
+#include <shell/cc-panel.h>
+
+G_BEGIN_DECLS
+
+#define CC_TYPE_PRINTERS_PANEL (cc_printers_panel_get_type ())
+G_DECLARE_FINAL_TYPE (CcPrintersPanel, cc_printers_panel, CC, PRINTERS_PANEL, CcPanel)
+
+G_END_DECLS
diff --git a/panels/printers/gnome-printers-panel.desktop.in.in b/panels/printers/gnome-printers-panel.desktop.in.in
new file mode 100644
index 0000000..6ad952d
--- /dev/null
+++ b/panels/printers/gnome-printers-panel.desktop.in.in
@@ -0,0 +1,17 @@
+[Desktop Entry]
+Name=Printers
+Comment=Add printers, view printer jobs and decide how you want to print
+Exec=gnome-control-center printers
+# Translators: Do NOT translate or transliterate this text (this is an icon file name)!
+Icon=org.gnome.Settings-printers-symbolic
+Terminal=false
+Type=Application
+NoDisplay=true
+StartupNotify=true
+# The X-GNOME-Settings-Panel is necessary to show in the main shell UI
+Categories=GNOME;GTK;Settings;HardwareSettings;X-GNOME-Settings-Panel;X-GNOME-DevicesSettings;
+OnlyShowIn=GNOME;Unity;
+# Translators: Search terms to find the Printers panel. Do NOT translate or localize the semicolons! The list MUST also end with a semicolon!
+Keywords=Printer;Queue;Print;Paper;Ink;Toner;
+# Notifications are emitted by gnome-settings-daemon
+X-GNOME-UsesNotifications=true
diff --git a/panels/printers/icons/meson.build b/panels/printers/icons/meson.build
new file mode 100644
index 0000000..d44c8f5
--- /dev/null
+++ b/panels/printers/icons/meson.build
@@ -0,0 +1,4 @@
+install_data(
+  'scalable/org.gnome.Settings-printers-symbolic.svg',
+  install_dir: join_paths(control_center_icondir, 'hicolor', 'scalable', 'apps')
+)
diff --git a/panels/printers/icons/scalable/org.gnome.Settings-printers-symbolic.svg b/panels/printers/icons/scalable/org.gnome.Settings-printers-symbolic.svg
new file mode 100644
index 0000000..bd21973
--- /dev/null
+++ b/panels/printers/icons/scalable/org.gnome.Settings-printers-symbolic.svg
@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<svg height="16px" viewBox="0 0 16 16" width="16px" xmlns="http://www.w3.org/2000/svg">
+    <g fill="#2e3436">
+        <path d="m 4 2 v 1 h 8 v -1 c 0 -0.550781 -0.449219 -1 -1 -1 h -6 c -0.550781 0 -1 0.449219 -1 1 z m 0 0"/>
+        <path d="m 4 8 c -1.089844 0 -2 0.910156 -2 2 v 3 c 0 1.089844 0.910156 2 2 2 h 8 c 1.089844 0 2 -0.910156 2 -2 v -3 c 0 -1.089844 -0.910156 -2 -2 -2 z m 0 2 h 8 v 3 h -8 z m 0 0"/>
+        <path d="m 2 4 c -1.109375 0 -2 0.890625 -2 2 v 4 c 0 1.109375 0.890625 2 2 2 h 1 v -2 c 0 -0.554688 0.445312 -1 1 -1 h 8 c 0.554688 0 1 0.445312 1 1 v 2 h 1 c 1.109375 0 2 -0.890625 2 -2 v -4 c 0 -1.109375 -0.890625 -2 -2 -2 z m 0 0"/>
+    </g>
+</svg>
diff --git a/panels/printers/meson.build b/panels/printers/meson.build
new file mode 100644
index 0000000..3f50979
--- /dev/null
+++ b/panels/printers/meson.build
@@ -0,0 +1,76 @@
+panels_list += cappletname
+desktop = 'gnome-@0@-panel.desktop'.format(cappletname)
+
+desktop_in = configure_file(
+  input: desktop + '.in.in',
+  output: desktop + '.in',
+  configuration: desktop_conf
+)
+
+i18n.merge_file(
+  type: 'desktop',
+  input: desktop_in,
+  output: desktop,
+  po_dir: po_dir,
+  install: true,
+  install_dir: control_center_desktopdir
+)
+
+sources = files(
+  'cc-printers-panel.c',
+  'pp-cups.c',
+  'pp-details-dialog.c',
+  'pp-host.c',
+  'pp-ipp-option-widget.c',
+  'pp-job.c',
+  'pp-job-row.c',
+  'pp-jobs-dialog.c',
+  'pp-maintenance-command.c',
+  'pp-new-printer-dialog.c',
+  'pp-new-printer.c',
+  'pp-options-dialog.c',
+  'pp-ppd-option-widget.c',
+  'pp-ppd-selection-dialog.c',
+  'pp-print-device.c',
+  'pp-printer-entry.c',
+  'pp-printer.c',
+  'pp-samba.c',
+  'pp-utils.c'
+)
+
+resource_data = files(
+  'new-printer-dialog.ui',
+  'ppd-selection-dialog.ui',
+  'pp-details-dialog.ui',
+  'pp-job-row.ui',
+  'pp-jobs-dialog.ui',
+  'pp-options-dialog.ui',
+  'printer-entry.ui',
+  'printers.ui'
+)
+
+sources += gnome.compile_resources(
+  'cc-' + cappletname + '-resources',
+  cappletname + '.gresource.xml',
+  c_name: 'cc_' + cappletname,
+  dependencies: resource_data,
+  export: true
+)
+
+deps = common_deps + [
+  cups_dep,
+  m_dep,
+  polkit_gobject_dep,
+  dependency('smbclient')
+]
+
+printers_panel_lib = static_library(
+  cappletname,
+  sources: sources,
+  include_directories: [top_inc, common_inc, shell_inc],
+  dependencies: deps,
+  c_args: cflags + cups_cflags,
+)
+panels_libs += [ printers_panel_lib ]
+
+subdir('icons')
diff --git a/panels/printers/new-printer-dialog.ui b/panels/printers/new-printer-dialog.ui
new file mode 100644
index 0000000..6c24ac1
--- /dev/null
+++ b/panels/printers/new-printer-dialog.ui
@@ -0,0 +1,378 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<interface>
+  <requires lib="gtk+" version="3.14"/>
+  <object class="GtkListStore" id="devices_liststore">
+    <columns>
+      <!-- column-name device_gicon -->
+      <column type="GIcon"/>
+      <!-- column-name device_name -->
+      <column type="gchararray"/>
+      <!-- column-name device_display_name -->
+      <column type="gchararray"/>
+      <!-- column-name device_description -->
+      <column type="gchararray"/>
+      <!-- column-name server_needs_authentication -->
+      <column type="gboolean"/>
+      <!-- column-name device_visible -->
+      <column type="gboolean"/>
+      <!-- column-name device -->
+      <column type="PpPrintDevice"/>
+    </columns>
+  </object>
+  <object class="GtkTreeModelFilter" id="devices_model_filter">
+    <property name="child_model">devices_liststore</property>
+  </object>
+  <template class="PpNewPrinterDialog" parent="GtkDialog">
+    <property name="width_request">480</property>
+    <property name="height_request">490</property>
+    <property name="title" translatable="yes" comments="Translators: This is the title presented at top of the dialog.">Add Printer</property>
+    <property name="resizable">False</property>
+    <property name="modal">True</property>
+    <property name="destroy_with_parent">True</property>
+    <property name="use_header_bar">1</property>
+    <child internal-child="headerbar">
+      <object class="GtkHeaderBar" id="headerbar">
+        <property name="show-title-buttons">False</property>
+        <property name="title-widget">
+          <object class="AdwWindowTitle" id="header_title">
+            <property name="title" translatable="yes" comments="Translators: This is the title presented at top of the dialog.">Add Printer</property>
+          </object>
+        </property>
+        <child>
+          <object class="GtkStack" id="headerbar_topleft_buttons">
+            <property name="valign">center</property>
+
+            <child>
+              <object class="GtkStackPage">
+                <property name="name">addprinter-page</property>
+                <property name="child">
+                  <object class="GtkButton" id="new_printer_cancel_button">
+                    <property name="label" translatable="yes">_Cancel</property>
+                    <property name="use_underline">True</property>
+                  </object>
+                </property>
+              </object>
+            </child>
+
+            <child>
+              <object class="GtkStackPage">
+                <property name="name">authentication-page</property>
+                <property name="child">
+                  <object class="GtkButton" id="go_back_button">
+                    <property name="halign">start</property>
+                    <accessibility>
+                      <property name="label" translatable="yes">Back</property>
+                    </accessibility>
+                    <child>
+                      <object class="GtkImage">
+                        <property name="icon-name">go-previous-symbolic</property>
+                      </object>
+                    </child>
+                  </object>
+                </property>
+              </object>
+            </child>
+
+          </object>
+        </child>
+        <child type="end">
+          <object class="GtkStack" id="headerbar_topright_buttons">
+            <property name="valign">center</property>
+
+            <child>
+              <object class="GtkStackPage">
+                <property name="name">addprinter-page</property>
+                <property name="child">
+                  <object class="GtkButton" id="new_printer_add_button">
+                    <property name="label" translatable="yes">_Add</property>
+                    <property name="sensitive">False</property>
+                    <property name="use_underline">True</property>
+                    <style>
+                      <class name="suggested-action"/>
+                    </style>
+                  </object>
+                </property>
+              </object>
+            </child>
+
+            <child>
+              <object class="GtkStackPage">
+                <property name="name">unlock_button</property>
+                <property name="child">
+                  <object class="GtkButton" id="unlock_button">
+                    <property name="label" translatable="yes" comments="Translators: This button opens authentication dialog for selected server.">_Unlock</property>
+                    <property name="use_underline">True</property>
+                    <style>
+                      <class name="suggested-action"/>
+                    </style>
+                  </object>
+                </property>
+              </object>
+            </child>
+
+            <child>
+              <object class="GtkStackPage">
+                <property name="name">authentication-page</property>
+                <property name="child">
+                  <object class="GtkButton" id="authenticate_button">
+                    <property name="label" translatable="yes" comments="Translators: This buttons submits the credentials for the selected server.">_Unlock</property>
+                    <property name="use_underline">True</property>
+                    <style>
+                      <class name="suggested-action"/>
+                    </style>
+                  </object>
+                </property>
+              </object>
+            </child>
+
+          </object>
+        </child>
+      </object>
+    </child>
+    <child>
+      <object class="GtkBox" id="dialog-vbox1">
+        <property name="orientation">vertical</property>
+        <property name="spacing">10</property>
+        <child>
+          <object class="GtkStack" id="dialog_stack">
+            <child>
+              <object class="GtkStackPage">
+                <property name="name">addprinter-page</property>
+                <property name="child">
+                  <object class="GtkBox" id="box2">
+                    <property name="orientation">vertical</property>
+                    <property name="hexpand">True</property>
+                    <property name="vexpand">True</property>
+                    <child>
+                      <object class="GtkStack" id="stack">
+                        <property name="hexpand">True</property>
+                        <property name="vexpand">True</property>
+                        <property name="transition-type">none</property>
+                        <style>
+                          <class name="view"/>
+                        </style>
+
+                        <child>
+                          <object class="GtkStackPage">
+                            <property name="name">standard-page</property>
+                            <property name="child">
+                              <object class="GtkScrolledWindow" id="scrolledwindow1">
+                                <child>
+                                  <object class="GtkTreeView" id="devices_treeview">
+                                    <property name="model">devices_model_filter</property>
+                                    <property name="headers_visible">False</property>
+                                    <property name="enable-grid-lines">GTK_TREE_VIEW_GRID_LINES_HORIZONTAL</property>
+                                    <child internal-child="selection">
+                                      <object class="GtkTreeSelection" id="treeview-selection"/>
+                                    </child>
+                                  </object>
+                                </child>
+                              </object>
+                            </property>
+                          </object>
+                        </child>
+
+                        <child>
+                          <object class="GtkStackPage">
+                            <property name="name">no-printers-page</property>
+                            <property name="child">
+                              <object class="GtkBox">
+                                <property name="orientation">GTK_ORIENTATION_VERTICAL</property>
+                                <property name="valign">GTK_ALIGN_CENTER</property>
+                                <property name="spacing">10</property>
+                                <child>
+                                  <object class="GtkImage">
+                                    <property name="valign">GTK_ALIGN_START</property>
+                                    <property name="pixel_size">80</property>
+                                    <property name="icon_name">printer-symbolic</property>
+                                    <property name="opacity">0.6</property>
+                                    <style>
+                                      <class name="dim-label"/>
+                                    </style>
+                                  </object>
+                                </child>
+                                <child>
+                                  <object class="GtkLabel" id="no-devices-label">
+                                    <property name="sensitive">False</property>
+                                    <property name="label" translatable="yes" comments="Translators: No printers were detected">No Printers Found</property>
+                                    <property name="opacity">0.6</property>
+                                    <attributes>
+                                      <attribute name="weight" value="bold"/>
+                                    </attributes>
+                                  </object>
+                                </child>
+                              </object>
+                            </property>
+                          </object>
+                        </child>
+
+                        <child>
+                          <object class="GtkStackPage">
+                            <property name="name">loading-page</property>
+                            <property name="child">
+                              <object class="GtkBox">
+                                <style>
+                                  <class name="view"/>
+                                </style>
+                                <child>
+                                  <object class="GtkSpinner" id="spinner">
+                                    <property name="spinning">True</property>
+                                    <property name="hexpand">True</property>
+                                    <property name="vexpand">True</property>
+                                    <property name="halign">center</property>
+                                    <property name="valign">center</property>
+                                    <property name="sensitive">False</property>
+                                    <property name="opacity">0.6</property>
+                                  </object>
+                                </child>
+                              </object>
+                            </property>
+                          </object>
+                        </child>
+
+                      </object>
+                    </child>
+                    <child>
+                      <object class="GtkSeparator" />
+                    </child>
+                    <child>
+                      <object class="GtkBox" id="box1">
+                        <property name="margin-top">4</property>
+                        <property name="margin-bottom">4</property>
+                        <property name="margin-start">4</property>
+                        <property name="margin-end">4</property>
+                        <child>
+                          <object class="GtkSearchEntry" id="search_entry">
+                            <property name="has_tooltip">True</property>
+                            <property name="placeholder_text" translatable="yes" comments="Translators: The entered text should contain network address of a printer or a text which will filter found devices (their names and locations)">Enter a network address or search for a printer</property>
+                            <property name="margin_start">40</property>
+                            <property name="margin_end">40</property>
+                            <property name="hexpand">True</property>
+                            <accessibility>
+                              <property name="label" translatable="yes">Search</property>
+                            </accessibility>
+                          </object>
+                        </child>
+                      </object>
+                    </child>
+                  </object>
+                </property>
+              </object>
+            </child>
+
+            <child>
+              <object class="GtkStackPage">
+                <property name="name">authentication-page</property>
+                <property name="child">
+                  <object class="GtkGrid">
+                    <property name="margin-top">20</property>
+                    <property name="margin-bottom">20</property>
+                    <property name="margin-start">20</property>
+                    <property name="margin-end">20</property>
+                    <property name="row_spacing">10</property>
+                    <property name="column_spacing">15</property>
+                    <property name="hexpand">True</property>
+                    <property name="vexpand">True</property>
+                    <style>
+                      <class name="background"/>
+                    </style>
+                    <child>
+                      <object class="GtkImage">
+                        <property name="pixel_size">48</property>
+                        <property name="icon_name">dialog-password-symbolic</property>
+                        <layout>
+                          <property name="column">0</property>
+                          <property name="row">0</property>
+                          <property name="row-span">2</property>
+                        </layout>
+                      </object>
+                    </child>
+                    <child>
+                      <object class="GtkLabel" id="authentication_title">
+                        <property name="label" translatable="yes">Authentication Required</property>
+                        <property name="xalign">0</property>
+                        <layout>
+                          <property name="column">1</property>
+                          <property name="row">0</property>
+                        </layout>
+                        <attributes>
+                          <attribute name="weight" value="bold"/>
+                        </attributes>
+                      </object>
+                    </child>
+                    <child>
+                      <object class="GtkLabel" id="authentication_text">
+                        <property name="wrap">True</property>
+                        <property name="max_width_chars">36</property>
+                        <property name="xalign">0</property>
+                        <property name="label" translatable="yes">Enter username and password to view printers on Print Server.</property>
+                        <layout>
+                          <property name="column">1</property>
+                          <property name="row">1</property>
+                        </layout>
+                      </object>
+                    </child>
+                    <child>
+                      <object class="GtkLabel">
+                        <property name="label" translatable="yes">Username</property>
+                        <property name="mnemonic_widget">username_entry</property>
+                        <layout>
+                          <property name="column">0</property>
+                          <property name="row">2</property>
+                        </layout>
+                      </object>
+                    </child>
+                    <child>
+                      <object class="GtkEntry" id="username_entry">
+                        <property name="invisible_char">●</property>
+                        <property name="activates_default">True</property>
+                        <property name="hexpand">True</property>
+                        <layout>
+                          <property name="column">1</property>
+                          <property name="row">2</property>
+                        </layout>
+                      </object>
+                    </child>
+                    <child>
+                      <object class="GtkLabel">
+                        <property name="label" translatable="yes">Password</property>
+                        <property name="mnemonic_widget">password_entry</property>
+                        <layout>
+                          <property name="column">0</property>
+                          <property name="row">3</property>
+                        </layout>
+                      </object>
+                    </child>
+                    <child>
+                      <object class="GtkEntry" id="password_entry">
+                        <property name="visibility">False</property>
+                        <property name="invisible_char">●</property>
+                        <property name="activates_default">True</property>
+                        <property name="hexpand">True</property>
+                        <layout>
+                          <property name="column">1</property>
+                          <property name="row">3</property>
+                        </layout>
+                      </object>
+                    </child>
+                  </object>
+                </property>
+              </object>
+            </child>
+
+          </object>
+        </child>
+      </object>
+    </child>
+    <action-widgets>
+      <action-widget response="-6">new_printer_cancel_button</action-widget>
+      <action-widget response="-5">new_printer_add_button</action-widget>
+    </action-widgets>
+  </template>
+  <object class="GtkSizeGroup">
+    <widgets>
+      <widget name="new_printer_cancel_button"/>
+      <widget name="headerbar_topright_buttons"/>
+    </widgets>
+  </object>
+</interface>
diff --git a/panels/printers/pp-cups.c b/panels/printers/pp-cups.c
new file mode 100644
index 0000000..9942579
--- /dev/null
+++ b/panels/printers/pp-cups.c
@@ -0,0 +1,313 @@
+/* -*- 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 2 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, see <http://www.gnu.org/licenses/>.
+ *
+ * Author: Marek Kasik <mkasik@redhat.com>
+ */
+
+#include "config.h"
+
+#include "pp-cups.h"
+
+#if (CUPS_VERSION_MAJOR > 1) || (CUPS_VERSION_MINOR > 5)
+#define HAVE_CUPS_1_6 1
+#endif
+
+#ifndef HAVE_CUPS_1_6
+#define ippGetInteger(attr, element) attr->values[element].integer
+#define ippGetStatusCode(ipp) ipp->request.status.status_code
+#endif
+
+struct _PpCups
+{
+  GObject parent_instance;
+};
+
+G_DEFINE_TYPE (PpCups, pp_cups, G_TYPE_OBJECT);
+
+static void
+pp_cups_class_init (PpCupsClass *klass)
+{
+}
+
+static void
+pp_cups_init (PpCups *self)
+{
+}
+
+PpCups *
+pp_cups_new ()
+{
+  return g_object_new (PP_TYPE_CUPS, NULL);
+}
+
+static void
+pp_cups_dests_free (PpCupsDests *dests)
+{
+  cupsFreeDests (dests->num_of_dests, dests->dests);
+}
+
+static void
+_pp_cups_get_dests_thread (GTask        *task,
+                           gpointer     *object,
+                           gpointer      task_data,
+                           GCancellable *cancellable)
+{
+  PpCupsDests *dests;
+
+  dests = g_new0 (PpCupsDests, 1);
+  dests->num_of_dests = cupsGetDests (&dests->dests);
+
+  if (g_task_set_return_on_cancel (task, FALSE))
+    {
+      g_task_return_pointer (task, dests, (GDestroyNotify) pp_cups_dests_free);
+    }
+  else
+    {
+      pp_cups_dests_free (dests);
+    }
+}
+
+void
+pp_cups_get_dests_async (PpCups              *self,
+                         GCancellable        *cancellable,
+                         GAsyncReadyCallback  callback,
+                         gpointer             user_data)
+{
+  g_autoptr(GTask) task = NULL;
+
+  task = g_task_new (self, cancellable, callback, user_data);
+  g_task_set_return_on_cancel (task, TRUE);
+  g_task_run_in_thread (task, (GTaskThreadFunc) _pp_cups_get_dests_thread);
+}
+
+PpCupsDests *
+pp_cups_get_dests_finish (PpCups        *self,
+                          GAsyncResult  *res,
+                          GError       **error)
+{
+  g_return_val_if_fail (g_task_is_valid (res, self), NULL);
+
+  return g_task_propagate_pointer (G_TASK (res), error);
+}
+
+static void
+connection_test_thread (GTask        *task,
+                        gpointer      source_object,
+                        gpointer      task_data,
+                        GCancellable *cancellable)
+{
+  http_t *http;
+
+#ifdef HAVE_CUPS_HTTPCONNECT2
+  http = httpConnect2 (cupsServer (), ippPort (), NULL, AF_UNSPEC,
+                       cupsEncryption (), 1, 30000, NULL);
+#else
+  http = httpConnectEncrypt (cupsServer (), ippPort (), cupsEncryption ());
+#endif
+  httpClose (http);
+
+  if (g_task_set_return_on_cancel (task, FALSE))
+    {
+      g_task_return_boolean (task, http != NULL);
+    }
+}
+
+void
+pp_cups_connection_test_async (PpCups              *self,
+                               GCancellable        *cancellable,
+                               GAsyncReadyCallback  callback,
+                               gpointer             user_data)
+{
+  g_autoptr(GTask) task = NULL;
+
+  task = g_task_new (self, cancellable, callback, user_data);
+  g_task_set_return_on_cancel (task, TRUE);
+  g_task_run_in_thread (task, connection_test_thread);
+}
+
+gboolean
+pp_cups_connection_test_finish (PpCups         *self,
+                                GAsyncResult   *result,
+                                GError        **error)
+{
+  g_return_val_if_fail (g_task_is_valid (result, self), FALSE);
+
+  return g_task_propagate_boolean (G_TASK (result), error);
+}
+
+/* Cancels subscription of given id */
+static void
+cancel_subscription_thread (GTask        *task,
+                            gpointer      source_object,
+                            gpointer      task_data,
+                            GCancellable *cancellable)
+{
+  ipp_t *request;
+  ipp_t *response = NULL;
+  gint   id = GPOINTER_TO_INT (task_data);
+
+  if (id >= 0)
+    {
+      request = ippNewRequest (IPP_CANCEL_SUBSCRIPTION);
+      ippAddString (request, IPP_TAG_OPERATION, IPP_TAG_URI,
+                    "printer-uri", NULL, "/");
+      ippAddString (request, IPP_TAG_OPERATION, IPP_TAG_NAME,
+                    "requesting-user-name", NULL, cupsUser ());
+      ippAddInteger (request, IPP_TAG_OPERATION, IPP_TAG_INTEGER,
+                     "notify-subscription-id", id);
+      response = cupsDoRequest (CUPS_HTTP_DEFAULT, request, "/");
+    }
+
+  g_task_return_boolean (task, response != NULL && ippGetStatusCode (response) <= IPP_OK);
+
+  ippDelete (response);
+}
+
+void
+pp_cups_cancel_subscription_async (PpCups              *self,
+                                   gint                 subscription_id,
+                                   GAsyncReadyCallback  callback,
+                                   gpointer             user_data)
+{
+  g_autoptr(GTask) task = NULL;
+
+  task = g_task_new (self, NULL, callback, user_data);
+  g_task_set_task_data (task, GINT_TO_POINTER (subscription_id), NULL);
+  g_task_run_in_thread (task, cancel_subscription_thread);
+}
+
+gboolean
+pp_cups_cancel_subscription_finish (PpCups       *self,
+                                    GAsyncResult *result)
+{
+  g_return_val_if_fail (g_task_is_valid (result, self), FALSE);
+
+  return g_task_propagate_boolean (G_TASK (result), NULL);
+}
+
+typedef struct {
+  gint id;
+  gchar **events;
+  int lease_duration;
+} CRSData;
+
+static void
+crs_data_free (CRSData *data)
+{
+  g_strfreev (data->events);
+  g_slice_free (CRSData, data);
+}
+
+static void
+renew_subscription_thread (GTask        *task,
+                           gpointer      source_object,
+                           gpointer      task_data,
+                           GCancellable *cancellable)
+{
+  ipp_attribute_t *attr = NULL;
+  CRSData         *subscription_data = task_data;
+  ipp_t           *request;
+  ipp_t           *response = NULL;
+  gint             result = -1;
+
+  if (g_cancellable_is_cancelled (cancellable))
+    return;
+
+  if (subscription_data->id > 0)
+    {
+      request = ippNewRequest (IPP_RENEW_SUBSCRIPTION);
+      ippAddString (request, IPP_TAG_OPERATION, IPP_TAG_URI,
+                   "printer-uri", NULL, "/");
+      ippAddString (request, IPP_TAG_OPERATION, IPP_TAG_NAME,
+                   "requesting-user-name", NULL, cupsUser ());
+      ippAddInteger (request, IPP_TAG_OPERATION, IPP_TAG_INTEGER,
+                    "notify-subscription-id", subscription_data->id);
+      ippAddInteger (request, IPP_TAG_SUBSCRIPTION, IPP_TAG_INTEGER,
+                    "notify-lease-duration", subscription_data->lease_duration);
+      response = cupsDoRequest (CUPS_HTTP_DEFAULT, request, "/");
+      if (response != NULL && ippGetStatusCode (response) <= IPP_OK_CONFLICT)
+        {
+          if ((attr = ippFindAttribute (response, "notify-lease-duration", IPP_TAG_INTEGER)) == NULL)
+            g_debug ("No notify-lease-duration in response!\n");
+          else if (ippGetInteger (attr, 0) == subscription_data->lease_duration)
+            result = subscription_data->id;
+        }
+    }
+
+  if (result < 0)
+    {
+      request = ippNewRequest (IPP_CREATE_PRINTER_SUBSCRIPTION);
+      ippAddString (request, IPP_TAG_OPERATION, IPP_TAG_URI,
+                   "printer-uri", NULL, "/");
+      ippAddString (request, IPP_TAG_OPERATION, IPP_TAG_NAME,
+                   "requesting-user-name", NULL, cupsUser ());
+      ippAddStrings (request, IPP_TAG_SUBSCRIPTION, IPP_TAG_KEYWORD,
+                    "notify-events", g_strv_length (subscription_data->events), NULL,
+                     (const char * const *) subscription_data->events);
+      ippAddString (request, IPP_TAG_SUBSCRIPTION, IPP_TAG_KEYWORD,
+                   "notify-pull-method", NULL, "ippget");
+      ippAddString (request, IPP_TAG_SUBSCRIPTION, IPP_TAG_URI,
+                   "notify-recipient-uri", NULL, "dbus://");
+      ippAddInteger (request, IPP_TAG_SUBSCRIPTION, IPP_TAG_INTEGER,
+                    "notify-lease-duration", subscription_data->lease_duration);
+      response = cupsDoRequest (CUPS_HTTP_DEFAULT, request, "/");
+
+      if (response != NULL && ippGetStatusCode (response) <= IPP_OK_CONFLICT)
+        {
+          if ((attr = ippFindAttribute (response, "notify-subscription-id", IPP_TAG_INTEGER)) == NULL)
+            g_debug ("No notify-subscription-id in response!\n");
+          else
+            result = ippGetInteger (attr, 0);
+        }
+    }
+
+  ippDelete (response);
+
+  g_task_return_int (task, result);
+}
+
+void
+pp_cups_renew_subscription_async  (PpCups               *self,
+                                   gint                  subscription_id,
+                                   gchar               **events,
+                                   gint                  lease_duration,
+                                   GCancellable         *cancellable,
+                                   GAsyncReadyCallback   callback,
+                                   gpointer              user_data)
+{
+  CRSData *subscription_data;
+  g_autoptr(GTask) task = NULL;
+
+  subscription_data = g_slice_new (CRSData);
+  subscription_data->id = subscription_id;
+  subscription_data->events = g_strdupv (events);
+  subscription_data->lease_duration = lease_duration;
+
+  task = g_task_new (self, cancellable, callback, user_data);
+  g_task_set_task_data (task, subscription_data, (GDestroyNotify) crs_data_free);
+  g_task_run_in_thread (task, renew_subscription_thread);
+}
+
+/* Returns id of renewed subscription or new id */
+gint
+pp_cups_renew_subscription_finish (PpCups       *self,
+                                   GAsyncResult *result)
+{
+  g_return_val_if_fail (g_task_is_valid (result, self), FALSE);
+
+  return g_task_propagate_int (G_TASK (result), NULL);
+}
diff --git a/panels/printers/pp-cups.h b/panels/printers/pp-cups.h
new file mode 100644
index 0000000..04063bb
--- /dev/null
+++ b/panels/printers/pp-cups.h
@@ -0,0 +1,76 @@
+/* -*- 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 2 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, see <http://www.gnu.org/licenses/>.
+ *
+ * Author: Marek Kasik <mkasik@redhat.com>
+ */
+
+#pragma once
+
+#include <glib-object.h>
+#include <gio/gio.h>
+#include "pp-utils.h"
+
+G_BEGIN_DECLS
+
+#define PP_TYPE_CUPS (pp_cups_get_type ())
+G_DECLARE_FINAL_TYPE (PpCups, pp_cups, PP, CUPS, GObject)
+
+typedef struct{
+  cups_dest_t *dests;
+  gint         num_of_dests;
+} PpCupsDests;
+
+PpCups      *pp_cups_new              (void);
+
+void         pp_cups_get_dests_async  (PpCups               *cups,
+                                       GCancellable         *cancellable,
+                                       GAsyncReadyCallback   callback,
+                                       gpointer              user_data);
+
+PpCupsDests *pp_cups_get_dests_finish (PpCups               *cups,
+                                       GAsyncResult         *result,
+                                       GError              **error);
+
+void         pp_cups_connection_test_async (PpCups              *cups,
+                                            GCancellable        *cancellable,
+                                            GAsyncReadyCallback  callback,
+                                            gpointer             user_data);
+
+gboolean     pp_cups_connection_test_finish (PpCups         *cups,
+                                             GAsyncResult   *result,
+                                             GError        **error);
+
+void         pp_cups_cancel_subscription_async    (PpCups              *cups,
+                                                   gint                 subscription_id,
+                                                   GAsyncReadyCallback  callback,
+                                                   gpointer             user_data);
+
+gboolean     pp_cups_cancel_subscription_finish   (PpCups                *cups,
+                                                   GAsyncResult          *result);
+
+void         pp_cups_renew_subscription_async  (PpCups                *cups,
+                                                gint                   subscription_id,
+                                                gchar                **events,
+                                                gint                   lease_duration,
+                                                GCancellable          *cancellable,
+                                                GAsyncReadyCallback    callback,
+                                                gpointer               user_data);
+
+gint         pp_cups_renew_subscription_finish (PpCups                *cups,
+                                                GAsyncResult          *result);
+
+G_END_DECLS
diff --git a/panels/printers/pp-details-dialog.c b/panels/printers/pp-details-dialog.c
new file mode 100644
index 0000000..6eeffb1
--- /dev/null
+++ b/panels/printers/pp-details-dialog.c
@@ -0,0 +1,399 @@
+/*
+ *
+ * Copyright 2016  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 2 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, see <http://www.gnu.org/licenses/>.
+ *
+ * Author: Felipe Borges <feborges@redhat.com>
+ */
+
+#include "config.h"
+
+#include <unistd.h>
+#include <stdlib.h>
+#include <sys/types.h>
+#include <sys/wait.h>
+
+#include <glib.h>
+#include <glib/gi18n.h>
+#include <glib/gstdio.h>
+#include <gtk/gtk.h>
+
+#include <cups/cups.h>
+#include <cups/ppd.h>
+
+#include "pp-details-dialog.h"
+#include "pp-ppd-selection-dialog.h"
+#include "pp-printer.h"
+#include "pp-utils.h"
+
+struct _PpDetailsDialog {
+  GtkDialog     parent_instance;
+
+  GtkLabel     *dialog_title;
+  GtkBox       *driver_buttons;
+  GtkBox       *loading_box;
+  GtkLabel     *printer_address_label;
+  GtkRevealer  *print_name_hint_revealer;
+  GtkEntry     *printer_location_entry;
+  GtkLabel     *printer_model_label;
+  GtkStack     *printer_model_stack;
+  GtkEntry     *printer_name_entry;
+  GtkButton    *search_for_drivers_button;
+
+  gchar        *printer_name;
+  gchar        *ppd_file_name;
+  PPDList      *all_ppds_list;
+  GCancellable *cancellable;
+
+  /* Dialogs */
+  PpPPDSelectionDialog *pp_ppd_selection_dialog;
+};
+
+G_DEFINE_TYPE (PpDetailsDialog, pp_details_dialog, GTK_TYPE_DIALOG)
+
+static void
+printer_name_changed (PpDetailsDialog *self)
+{
+  const gchar *name;
+  g_autofree gchar *title = NULL;
+
+  name = pp_details_dialog_get_printer_name (self);
+
+  if (printer_name_is_valid (name)){
+    /* Translators: This is the title of the dialog. %s is the printer name. */
+    title = g_strdup_printf (_("%s Details"), name);
+    gtk_revealer_set_reveal_child (self->print_name_hint_revealer, FALSE);
+    gtk_label_set_label (self->dialog_title, title);
+  } else {
+    gtk_revealer_set_reveal_child (self->print_name_hint_revealer, TRUE);
+  }
+}
+
+static void set_ppd_cb (const gchar *printer_name, gboolean success, gpointer user_data);
+
+static void
+get_ppd_names_cb (PPDName     **names,
+                  const gchar  *printer_name,
+                  gboolean      cancelled,
+                  gpointer      user_data)
+{
+  PpDetailsDialog *self = (PpDetailsDialog*) user_data;
+
+  if (!cancelled)
+    {
+      if (names != NULL)
+        {
+          gtk_label_set_text (self->printer_model_label, names[0]->ppd_display_name);
+          printer_set_ppd_async (printer_name,
+                                 names[0]->ppd_name,
+                                 self->cancellable,
+                                 set_ppd_cb,
+                                 self);
+        }
+      else
+        {
+          gtk_label_set_text (self->printer_model_label, _("No suitable driver found"));
+        }
+
+      gtk_stack_set_visible_child (self->printer_model_stack, GTK_WIDGET (self->printer_model_label));
+    }
+}
+
+static void
+search_for_drivers (PpDetailsDialog *self)
+{
+  gtk_stack_set_visible_child (self->printer_model_stack, GTK_WIDGET (self->loading_box));
+  gtk_widget_set_sensitive (GTK_WIDGET (self->search_for_drivers_button), FALSE);
+
+  get_ppd_names_async (self->printer_name,
+                       1,
+                       self->cancellable,
+                       get_ppd_names_cb,
+                       self);
+}
+
+static void
+set_ppd_cb (const gchar *printer_name,
+            gboolean  success,
+            gpointer  user_data)
+{
+  PpDetailsDialog *self = (PpDetailsDialog*) user_data;
+
+  gtk_label_set_text (GTK_LABEL (self->printer_model_label), self->ppd_file_name);
+}
+
+static void
+ppd_selection_dialog_response_cb (GtkDialog *dialog,
+                                  gint       response_id,
+                                  gpointer   user_data)
+{
+  PpDetailsDialog *self = (PpDetailsDialog*) user_data;
+
+  if (response_id == GTK_RESPONSE_OK)
+    {
+      g_autofree gchar *ppd_name = NULL;
+
+      ppd_name = pp_ppd_selection_dialog_get_ppd_name (self->pp_ppd_selection_dialog);
+
+      if (self->printer_name && ppd_name)
+        {
+          printer_set_ppd_async (self->printer_name,
+                                 ppd_name,
+                                 self->cancellable,
+                                 set_ppd_cb,
+                                 self);
+
+          g_clear_pointer (&self->ppd_file_name, g_free);
+          self->ppd_file_name = g_strdup (ppd_name);
+        }
+    }
+
+  gtk_window_destroy (GTK_WINDOW (self->pp_ppd_selection_dialog));
+  self->pp_ppd_selection_dialog = NULL;
+}
+
+static void
+get_all_ppds_async_cb (PPDList  *ppds,
+                       gpointer  user_data)
+{
+  PpDetailsDialog *self = user_data;
+
+  self->all_ppds_list = ppd_list_copy (ppds);
+
+  if (self->pp_ppd_selection_dialog)
+    pp_ppd_selection_dialog_set_ppd_list (self->pp_ppd_selection_dialog,
+                                          self->all_ppds_list);
+}
+
+static void
+select_ppd_in_dialog (PpDetailsDialog *self)
+{
+  g_autofree gchar *device_id = NULL;
+  g_autofree gchar *manufacturer = NULL;
+
+  g_clear_pointer (&self->ppd_file_name, g_free);
+  self->ppd_file_name = g_strdup (cupsGetPPD (self->printer_name));
+
+  if (!self->pp_ppd_selection_dialog)
+    {
+      device_id =
+        get_ppd_attribute (self->ppd_file_name,
+                           "1284DeviceID");
+
+      if (device_id)
+        {
+          manufacturer = get_tag_value (device_id, "mfg");
+          if (!manufacturer)
+            manufacturer = get_tag_value (device_id, "manufacturer");
+          }
+
+      if (manufacturer == NULL)
+        {
+          manufacturer =
+            get_ppd_attribute (self->ppd_file_name,
+                               "Manufacturer");
+          }
+
+      if (manufacturer == NULL)
+        {
+          manufacturer = g_strdup ("Raw");
+        }
+
+       if (self->all_ppds_list == NULL)
+         {
+           get_all_ppds_async (self->cancellable, get_all_ppds_async_cb, self);
+         }
+
+        self->pp_ppd_selection_dialog = pp_ppd_selection_dialog_new (
+          self->all_ppds_list,
+          manufacturer,
+          ppd_selection_dialog_response_cb,
+          self);
+
+        gtk_window_set_transient_for (GTK_WINDOW (self->pp_ppd_selection_dialog),
+                                      GTK_WINDOW (self));
+
+        gtk_widget_show (GTK_WIDGET (self->pp_ppd_selection_dialog));
+    }
+}
+
+static void
+ppd_file_select_response_cb (GtkDialog *dialog,
+                             gint       response_id,
+                             gpointer   user_data)
+{
+  PpDetailsDialog *self = PP_DETAILS_DIALOG (user_data);
+
+  if (response_id == GTK_RESPONSE_ACCEPT)
+    {
+      g_autoptr(GFile) file = NULL;
+      g_autofree gchar *ppd_filename = NULL;
+
+      file = gtk_file_chooser_get_file (GTK_FILE_CHOOSER (dialog));
+      ppd_filename = g_file_get_path (file);
+
+      if (self->printer_name && ppd_filename)
+        {
+          printer_set_ppd_file_async (self->printer_name,
+                                      ppd_filename,
+                                      self->cancellable,
+                                      set_ppd_cb,
+                                      self);
+        }
+    }
+
+  gtk_window_destroy (GTK_WINDOW (dialog));
+}
+
+static void
+select_ppd_manually (PpDetailsDialog *self)
+{
+  GtkFileFilter *filter;
+  GtkWidget     *dialog;
+
+  dialog = gtk_file_chooser_dialog_new (_("Select PPD File"),
+                                        GTK_WINDOW (self),
+                                        GTK_FILE_CHOOSER_ACTION_OPEN,
+                                        _("_Cancel"), GTK_RESPONSE_CANCEL,
+                                        _("_Open"), GTK_RESPONSE_ACCEPT,
+                                        NULL);
+
+  filter = gtk_file_filter_new ();
+  gtk_file_filter_set_name (filter,
+    _("PostScript Printer Description files (*.ppd, *.PPD, *.ppd.gz, *.PPD.gz, *.PPD.GZ)"));
+  gtk_file_filter_add_pattern (filter, "*.ppd");
+  gtk_file_filter_add_pattern (filter, "*.PPD");
+  gtk_file_filter_add_pattern (filter, "*.ppd.gz");
+  gtk_file_filter_add_pattern (filter, "*.PPD.gz");
+  gtk_file_filter_add_pattern (filter, "*.PPD.GZ");
+
+  gtk_file_chooser_set_filter (GTK_FILE_CHOOSER (dialog), filter);
+
+  gtk_widget_show (dialog);
+
+  g_signal_connect (dialog, "response", G_CALLBACK (ppd_file_select_response_cb), self);
+}
+
+static void
+update_sensitivity (PpDetailsDialog *self,
+                    gboolean         sensitive)
+{
+  gtk_widget_set_sensitive (GTK_WIDGET (self->printer_name_entry), sensitive);
+  gtk_widget_set_sensitive (GTK_WIDGET (self->printer_location_entry), sensitive);
+  gtk_widget_set_sensitive (GTK_WIDGET (self->driver_buttons), sensitive);
+}
+
+static void
+pp_details_dialog_init (PpDetailsDialog *self)
+{
+  gtk_widget_init_template (GTK_WIDGET (self));
+
+  self->cancellable = g_cancellable_new ();
+}
+
+static void
+pp_details_dialog_dispose (GObject *object)
+{
+  PpDetailsDialog *self = PP_DETAILS_DIALOG (object);
+
+  g_clear_pointer (&self->printer_name, g_free);
+  g_clear_pointer (&self->ppd_file_name, g_free);
+
+  if (self->all_ppds_list != NULL)
+    {
+      ppd_list_free (self->all_ppds_list);
+      self->all_ppds_list = NULL;
+    }
+
+  g_cancellable_cancel (self->cancellable);
+  g_clear_object (&self->cancellable);
+
+  G_OBJECT_CLASS (pp_details_dialog_parent_class)->dispose (object);
+}
+
+static void
+pp_details_dialog_class_init (PpDetailsDialogClass *klass)
+{
+  GObjectClass *object_class = G_OBJECT_CLASS (klass);
+  GtkWidgetClass *widget_class = GTK_WIDGET_CLASS (klass);
+
+  object_class->dispose = pp_details_dialog_dispose;
+
+  gtk_widget_class_set_template_from_resource (widget_class, "/org/gnome/control-center/printers/pp-details-dialog.ui");
+
+  gtk_widget_class_bind_template_child (widget_class, PpDetailsDialog, dialog_title);
+  gtk_widget_class_bind_template_child (widget_class, PpDetailsDialog, print_name_hint_revealer);
+  gtk_widget_class_bind_template_child (widget_class, PpDetailsDialog, driver_buttons);
+  gtk_widget_class_bind_template_child (widget_class, PpDetailsDialog, loading_box);
+  gtk_widget_class_bind_template_child (widget_class, PpDetailsDialog, printer_address_label);
+  gtk_widget_class_bind_template_child (widget_class, PpDetailsDialog, printer_location_entry);
+  gtk_widget_class_bind_template_child (widget_class, PpDetailsDialog, printer_model_label);
+  gtk_widget_class_bind_template_child (widget_class, PpDetailsDialog, printer_model_stack);
+  gtk_widget_class_bind_template_child (widget_class, PpDetailsDialog, printer_name_entry);
+  gtk_widget_class_bind_template_child (widget_class, PpDetailsDialog, search_for_drivers_button);
+
+  gtk_widget_class_bind_template_callback (widget_class, printer_name_changed);
+  gtk_widget_class_bind_template_callback (widget_class, search_for_drivers);
+  gtk_widget_class_bind_template_callback (widget_class, select_ppd_in_dialog);
+  gtk_widget_class_bind_template_callback (widget_class, select_ppd_manually);
+}
+
+PpDetailsDialog *
+pp_details_dialog_new (gchar   *printer_name,
+                       gchar   *printer_location,
+                       gchar   *printer_address,
+                       gchar   *printer_make_and_model,
+                       gboolean sensitive)
+{
+  PpDetailsDialog *self;
+  g_autofree gchar *title = NULL;
+  g_autofree gchar *printer_url = NULL;
+
+  self = g_object_new (PP_DETAILS_DIALOG_TYPE,
+                       "use-header-bar", TRUE,
+                       NULL);
+
+  self->printer_name = g_strdup (printer_name);
+  self->ppd_file_name = NULL;
+
+  /* Translators: This is the title of the dialog. %s is the printer name. */
+  title = g_strdup_printf (_("%s Details"), printer_name);
+  gtk_label_set_label (self->dialog_title, title);
+
+  printer_url = g_strdup_printf ("<a href=\"http://%s:%d\">%s</a>", printer_address, ippPort (), printer_address);
+  gtk_label_set_markup (GTK_LABEL (self->printer_address_label), printer_url);
+
+  gtk_editable_set_text (GTK_EDITABLE (self->printer_name_entry), printer_name);
+  gtk_editable_set_text (GTK_EDITABLE (self->printer_location_entry), printer_location);
+  gtk_label_set_text (GTK_LABEL (self->printer_model_label), printer_make_and_model);
+
+  update_sensitivity (self, sensitive);
+
+  return self;
+}
+
+const gchar *
+pp_details_dialog_get_printer_name (PpDetailsDialog *self)
+{
+  g_return_val_if_fail (PP_IS_DETAILS_DIALOG (self), NULL);
+  return gtk_editable_get_text (GTK_EDITABLE (self->printer_name_entry));
+}
+
+const gchar *
+pp_details_dialog_get_printer_location (PpDetailsDialog *self)
+{
+  g_return_val_if_fail (PP_IS_DETAILS_DIALOG (self), NULL);
+  return gtk_editable_get_text (GTK_EDITABLE (self->printer_location_entry));
+}
diff --git a/panels/printers/pp-details-dialog.h b/panels/printers/pp-details-dialog.h
new file mode 100644
index 0000000..8bb5a65
--- /dev/null
+++ b/panels/printers/pp-details-dialog.h
@@ -0,0 +1,41 @@
+/* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 8 -*-
+ *
+ * Copyright 2016  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 2 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, see <http://www.gnu.org/licenses/>.
+ *
+ * Author: Felipe Borges <feborges@redhat.com>
+ */
+
+#pragma once
+
+#include <gtk/gtk.h>
+#include "pp-utils.h"
+
+G_BEGIN_DECLS
+
+#define PP_DETAILS_DIALOG_TYPE (pp_details_dialog_get_type ())
+G_DECLARE_FINAL_TYPE (PpDetailsDialog, pp_details_dialog, PP, DETAILS_DIALOG, GtkDialog)
+
+PpDetailsDialog *pp_details_dialog_new                  (gchar   *printer_name,
+                                                         gchar   *printer_location,
+                                                         gchar   *printer_address,
+                                                         gchar   *printer_make_and_model,
+                                                         gboolean sensitive);
+
+const gchar     *pp_details_dialog_get_printer_name     (PpDetailsDialog *dialog);
+
+const gchar     *pp_details_dialog_get_printer_location (PpDetailsDialog *dialog);
+
+G_END_DECLS
diff --git a/panels/printers/pp-details-dialog.ui b/panels/printers/pp-details-dialog.ui
new file mode 100644
index 0000000..2dec9d4
--- /dev/null
+++ b/panels/printers/pp-details-dialog.ui
@@ -0,0 +1,235 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!-- Generated with glade 3.18.3 -->
+<interface>
+  <requires lib="gtk+" version="3.12"/>
+  <template class="PpDetailsDialog" parent="GtkDialog">
+    <property name="resizable">False</property>
+    <property name="modal">True</property>
+    <property name="destroy_with_parent">True</property>
+    <property name="use-header-bar">1</property>
+    <child internal-child="headerbar">
+      <object class="GtkHeaderBar">
+        <property name="show_title_buttons">True</property>
+        <child type="title">
+          <object class="GtkLabel" id="dialog_title">
+            <property name="wrap">True</property>
+            <property name="max_width_chars">30</property>
+            <property name="ellipsize">middle</property>
+            <property name="hexpand">true</property>
+            <attributes>
+              <attribute name="weight" value="bold"/>
+            </attributes>
+          </object>
+        </child>
+      </object>
+    </child>
+    <child>
+      <object class="GtkBox">
+        <property name="margin-top">20</property>
+        <property name="margin-bottom">20</property>
+        <property name="margin-start">20</property>
+        <property name="margin-end">20</property>
+        <property name="halign">center</property>
+        <child>
+          <object class="GtkGrid">
+            <property name="row-spacing">10</property>
+            <property name="column-spacing">10</property>
+            <child>
+              <object class="GtkLabel">
+                <property name="label" translatable="yes">Name</property>
+                <property name="halign">end</property>
+                <property name="mnemonic_widget">printer_name_entry</property>
+                <layout>
+                  <property name="column">0</property>
+                  <property name="row">0</property>
+                </layout>
+                <style>
+                  <class name="dim-label"/>
+                </style>
+              </object>
+            </child>
+            <child>
+              <object class="GtkEntry" id="printer_name_entry">
+                <property name="halign">fill</property>
+                <property name="width_request">320</property>
+                <signal name="changed" handler="printer_name_changed" object="PpDetailsDialog" swapped="yes"/>
+                <layout>
+                  <property name="column">1</property>
+                  <property name="row">0</property>
+                </layout>
+              </object>
+            </child>
+            <child>
+              <object class="GtkRevealer" id="print_name_hint_revealer">
+                <property name="visible">True</property>
+                <property name="can_focus">False</property>
+                <child>
+                  <object class="GtkLabel" id="print_name_hint_label">
+                    <property name="visible">True</property>
+                    <property name="label" translatable="yes">Printer names cannot contain SPACE, TAB, #, or /</property>
+                    <property name="yalign">0</property>
+                    <property name="xalign">0</property>
+                    <style>
+                      <class name="dim-label"/>
+                    </style>
+                    <attributes>
+                      <attribute name="scale" value="0.83"/>
+                    </attributes>
+                  </object>
+                </child>
+                <layout>
+                  <property name="column">1</property>
+                  <property name="row">1</property>
+                </layout>
+              </object>
+            </child>
+
+            <child>
+              <object class="GtkLabel">
+                <property name="label" translatable="yes">Location</property>
+                <property name="halign">end</property>
+                <property name="mnemonic_widget">printer_location_entry</property>
+                <layout>
+                  <property name="column">0</property>
+                  <property name="row">2</property>
+                </layout>
+                <style>
+                  <class name="dim-label"/>
+                </style>
+              </object>
+            </child>
+            <child>
+              <object class="GtkEntry" id="printer_location_entry">
+                <property name="width_request">320</property>
+                <property name="halign">fill</property>
+                <layout>
+                  <property name="column">1</property>
+                  <property name="row">2</property>
+                </layout>
+              </object>
+            </child>
+
+            <child>
+              <object class="GtkLabel">
+                <property name="label" translatable="yes">Address</property>
+                <property name="halign">end</property>
+                <property name="mnemonic_widget">printer_address_label</property>
+                <layout>
+                  <property name="column">0</property>
+                  <property name="row">3</property>
+                </layout>
+                <style>
+                  <class name="dim-label"/>
+                </style>
+              </object>
+            </child>
+            <child>
+              <object class="GtkLabel" id="printer_address_label">
+                <property name="label">192.168.0.1</property>
+                <property name="halign">start</property>
+                <layout>
+                  <property name="column">1</property>
+                  <property name="row">3</property>
+                </layout>
+              </object>
+            </child>
+
+            <child>
+              <object class="GtkLabel">
+                <property name="label" translatable="yes">Driver</property>
+                <property name="halign">end</property>
+                <property name="mnemonic_widget">printer_model_label</property>
+                <layout>
+                  <property name="column">0</property>
+                  <property name="row">4</property>
+                </layout>
+                <style>
+                  <class name="dim-label"/>
+                </style>
+              </object>
+            </child>
+            <child>
+              <object class="GtkStack" id="printer_model_stack">
+                <property name="halign">start</property>
+                <layout>
+                  <property name="column">1</property>
+                  <property name="row">4</property>
+                </layout>
+                <child>
+                  <object class="GtkLabel" id="printer_model_label">
+                    <property name="halign">start</property>
+                    <property name="label">HP Inkjet Delux 9000</property>
+                    <property name="selectable">True</property>
+                  </object>
+                </child>
+                <child>
+                  <object class="GtkBox" id="loading_box">
+                    <property name="halign">start</property>
+                    <property name="spacing">5</property>
+                    <child>
+                      <object class="GtkSpinner">
+                        <property name="spinning">True</property>
+                        <property name="halign">start</property>
+                      </object>
+                    </child>
+                    <child>
+                      <object class="GtkLabel">
+                        <property name="halign">start</property>
+                        <property name="label" translatable="yes">Searching for preferred drivers…</property>
+                      </object>
+                    </child>
+                  </object>
+                </child>
+              </object>
+            </child>
+
+            <child>
+              <object class="GtkBox" id="driver_buttons">
+                <property name="orientation">vertical</property>
+                <property name="spacing">10</property>
+                <property name="halign">start</property>
+                <layout>
+                  <property name="column">1</property>
+                  <property name="row">5</property>
+                </layout>
+                <child>
+                  <object class="GtkButton" id="search_for_drivers_button">
+                    <property name="label" translatable="yes">Search for Drivers</property>
+                    <property name="halign">fill</property>
+                    <signal name="clicked" handler="search_for_drivers" object="PpDetailsDialog" swapped="yes"/>
+                  </object>
+                </child>
+
+                <child>
+                  <object class="GtkButton" id="select_from_database_button">
+                    <property name="label" translatable="yes">Select from Database…</property>
+                    <property name="halign">fill</property>
+                    <signal name="clicked" handler="select_ppd_in_dialog" object="PpDetailsDialog" swapped="yes"/>
+                  </object>
+                </child>
+
+                <child>
+                  <object class="GtkButton" id="install_ppd_button">
+                    <property name="label" translatable="yes">Install PPD File…</property>
+                    <property name="halign">fill</property>
+                    <signal name="clicked" handler="select_ppd_manually" object="PpDetailsDialog" swapped="yes"/>
+                  </object>
+                </child>
+              </object>
+
+            </child>
+          </object>
+        </child>
+      </object>
+    </child>
+  </template>
+
+  <object class="GtkSizeGroup">
+    <property name="mode">horizontal</property>
+    <widgets>
+      <widget name="search_for_drivers_button"/>
+      <widget name="select_from_database_button"/>
+      <widget name="install_ppd_button"/>
+    </widgets>
+  </object>
+</interface>
diff --git a/panels/printers/pp-host.c b/panels/printers/pp-host.c
new file mode 100644
index 0000000..a31a606
--- /dev/null
+++ b/panels/printers/pp-host.c
@@ -0,0 +1,747 @@
+/* -*- 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 2 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, see <http://www.gnu.org/licenses/>.
+ *
+ * Author: Marek Kasik <mkasik@redhat.com>
+ */
+
+#include "config.h"
+
+#include "pp-host.h"
+
+#include <glib/gi18n.h>
+
+#define BUFFER_LENGTH 1024
+
+typedef struct
+{
+  gchar *hostname;
+  gint   port;
+} PpHostPrivate;
+
+G_DEFINE_TYPE_WITH_PRIVATE (PpHost, pp_host, G_TYPE_OBJECT);
+
+enum {
+  PROP_0 = 0,
+  PROP_HOSTNAME,
+  PROP_PORT,
+};
+
+enum {
+  AUTHENTICATION_REQUIRED,
+  LAST_SIGNAL
+};
+
+static guint signals[LAST_SIGNAL] = { 0 };
+
+static void
+pp_host_finalize (GObject *object)
+{
+  PpHost *self = PP_HOST (object);
+  PpHostPrivate *priv = pp_host_get_instance_private (self);
+
+  g_clear_pointer (&priv->hostname, g_free);
+
+  G_OBJECT_CLASS (pp_host_parent_class)->finalize (object);
+}
+
+static void
+pp_host_get_property (GObject    *object,
+                      guint       prop_id,
+                      GValue     *value,
+                      GParamSpec *param_spec)
+{
+  PpHost *self = PP_HOST (object);
+  PpHostPrivate *priv = pp_host_get_instance_private (self);
+
+  switch (prop_id)
+    {
+      case PROP_HOSTNAME:
+        g_value_set_string (value, priv->hostname);
+        break;
+      case PROP_PORT:
+        g_value_set_int (value, priv->port);
+        break;
+      default:
+        G_OBJECT_WARN_INVALID_PROPERTY_ID (object,
+                                           prop_id,
+                                           param_spec);
+      break;
+    }
+}
+
+static void
+pp_host_set_property (GObject      *object,
+                      guint         prop_id,
+                      const GValue *value,
+                      GParamSpec   *param_spec)
+{
+  PpHost *self = PP_HOST (object);
+  PpHostPrivate *priv = pp_host_get_instance_private (self);
+
+  switch (prop_id)
+    {
+      case PROP_HOSTNAME:
+        g_free (priv->hostname);
+        priv->hostname = g_value_dup_string (value);
+        break;
+      case PROP_PORT:
+        priv->port = g_value_get_int (value);
+        break;
+      default:
+        G_OBJECT_WARN_INVALID_PROPERTY_ID (object,
+                                           prop_id,
+                                           param_spec);
+        break;
+    }
+}
+
+static void
+pp_host_class_init (PpHostClass *klass)
+{
+  GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
+
+  gobject_class->set_property = pp_host_set_property;
+  gobject_class->get_property = pp_host_get_property;
+  gobject_class->finalize = pp_host_finalize;
+
+  g_object_class_install_property (gobject_class, PROP_HOSTNAME,
+    g_param_spec_string ("hostname",
+                         "Hostname",
+                         "The hostname",
+                         NULL,
+                         G_PARAM_READWRITE));
+
+  g_object_class_install_property (gobject_class, PROP_PORT,
+    g_param_spec_int ("port",
+                      "Port",
+                      "The port",
+                      -1, G_MAXINT32, PP_HOST_UNSET_PORT,
+                      G_PARAM_READWRITE));
+
+  signals[AUTHENTICATION_REQUIRED] =
+    g_signal_new ("authentication-required",
+                  G_TYPE_FROM_CLASS (klass),
+                  G_SIGNAL_RUN_LAST,
+                  0,
+                  NULL, NULL, NULL,
+                  G_TYPE_NONE, 0);
+}
+
+static void
+pp_host_init (PpHost *self)
+{
+  PpHostPrivate *priv = pp_host_get_instance_private (self);
+  priv->port = PP_HOST_UNSET_PORT;
+}
+
+PpHost *
+pp_host_new (const gchar *hostname)
+{
+  return g_object_new (PP_TYPE_HOST,
+                       "hostname", hostname,
+                       NULL);
+}
+
+static gchar **
+line_split (gchar *line)
+{
+  gboolean          escaped = FALSE;
+  gboolean          quoted = FALSE;
+  gboolean          in_word = FALSE;
+  gchar           **words = NULL;
+  gchar           **result = NULL;
+  g_autofree gchar *buffer = NULL;
+  gchar             ch;
+  gint              n = 0;
+  gint              i, j = 0, k = 0;
+
+  if (line)
+    {
+      n = strlen (line);
+      words = g_new0 (gchar *, n + 1);
+      buffer = g_new0 (gchar, n + 1);
+
+      for (i = 0; i < n; i++)
+        {
+          ch = line[i];
+
+          if (escaped)
+            {
+              buffer[k++] = ch;
+              escaped = FALSE;
+              continue;
+            }
+
+          if (ch == '\\')
+            {
+              in_word = TRUE;
+              escaped = TRUE;
+              continue;
+            }
+
+          if (in_word)
+            {
+              if (quoted)
+                {
+                  if (ch == '"')
+                    quoted = FALSE;
+                  else
+                    buffer[k++] = ch;
+                }
+              else if (g_ascii_isspace (ch))
+                {
+                  words[j++] = g_strdup (buffer);
+                  memset (buffer, 0, n + 1);
+                  k = 0;
+                  in_word = FALSE;
+                }
+              else if (ch == '"')
+                quoted = TRUE;
+              else
+                buffer[k++] = ch;
+            }
+          else
+            {
+              if (ch == '"')
+                {
+                  in_word = TRUE;
+                  quoted = TRUE;
+                }
+              else if (!g_ascii_isspace (ch))
+                {
+                  in_word = TRUE;
+                  buffer[k++] = ch;
+                }
+            }
+        }
+    }
+
+  if (buffer && buffer[0] != '\0')
+    words[j++] = g_strdup (buffer);
+
+  result = g_strdupv (words);
+  g_strfreev (words);
+
+  return result;
+}
+
+static void
+_pp_host_get_snmp_devices_thread (GTask        *task,
+                                  gpointer      source_object,
+                                  gpointer      task_data,
+                                  GCancellable *cancellable)
+{
+  PpHost           *self = source_object;
+  PpHostPrivate    *priv = pp_host_get_instance_private (self);
+  g_autoptr(GPtrArray) devices = NULL;
+  g_autoptr(GError) error = NULL;
+  g_auto(GStrv)     argv = NULL;
+  g_autofree gchar *stdout_string = NULL;
+  gint              exit_status;
+
+  devices = g_ptr_array_new_with_free_func (g_object_unref);
+
+  argv = g_new0 (gchar *, 3);
+  argv[0] = g_strdup ("/usr/lib/cups/backend/snmp");
+  argv[1] = g_strdup (priv->hostname);
+
+  /* Use SNMP to get printer's informations */
+  g_spawn_sync (NULL,
+                argv,
+                NULL,
+                G_SPAWN_STDERR_TO_DEV_NULL,
+                NULL,
+                NULL,
+                &stdout_string,
+                NULL,
+                &exit_status,
+                &error);
+
+  if (exit_status == 0 && stdout_string)
+    {
+      g_auto(GStrv)     printer_informations = NULL;
+      gint              length;
+
+      printer_informations = line_split (stdout_string);
+      length = g_strv_length (printer_informations);
+
+      if (length >= 4)
+        {
+          g_autofree gchar *device_name = NULL;
+          gboolean is_network_device;
+          PpPrintDevice *device;
+
+          device_name = g_strdup (printer_informations[3]);
+          g_strcanon (device_name, ALLOWED_CHARACTERS, '-');
+          is_network_device = g_strcmp0 (printer_informations[0], "network") == 0;
+
+          device = g_object_new (PP_TYPE_PRINT_DEVICE,
+                                 "is-network-device", is_network_device,
+                                 "device-uri", printer_informations[1],
+                                 "device-make-and-model", printer_informations[2],
+                                 "device-info", printer_informations[3],
+                                 "acquisition-method", ACQUISITION_METHOD_SNMP,
+                                 "device-name", device_name,
+                                 NULL);
+
+          if (length >= 5 && printer_informations[4][0] != '\0')
+            g_object_set (device, "device-id", printer_informations[4], NULL);
+
+          if (length >= 6 && printer_informations[5][0] != '\0')
+            g_object_set (device, "device-location", printer_informations[5], NULL);
+
+          g_ptr_array_add (devices, device);
+        }
+    }
+
+  g_task_return_pointer (task, g_ptr_array_ref (devices), (GDestroyNotify) g_ptr_array_unref);
+}
+
+void
+pp_host_get_snmp_devices_async (PpHost              *self,
+                                GCancellable        *cancellable,
+                                GAsyncReadyCallback  callback,
+                                gpointer             user_data)
+{
+  g_autoptr(GTask) task = NULL;
+
+  task = g_task_new (self, cancellable, callback, user_data);
+  g_task_run_in_thread (task, _pp_host_get_snmp_devices_thread);
+}
+
+GPtrArray *
+pp_host_get_snmp_devices_finish (PpHost        *self,
+                                 GAsyncResult  *res,
+                                 GError       **error)
+{
+  g_return_val_if_fail (g_task_is_valid (res, self), NULL);
+  g_return_val_if_fail (error == NULL || *error == NULL, NULL);
+  return g_task_propagate_pointer (G_TASK (res), error);
+}
+
+static void
+_pp_host_get_remote_cups_devices_thread (GTask        *task,
+                                         gpointer      source_object,
+                                         gpointer      task_data,
+                                         GCancellable *cancellable)
+{
+  cups_dest_t   *dests = NULL;
+  PpHost        *self = (PpHost *) source_object;
+  PpHostPrivate *priv = pp_host_get_instance_private (self);
+  g_autoptr(GPtrArray) devices = NULL;
+  http_t        *http;
+  gint           num_of_devices = 0;
+  gint           port;
+  gint           i;
+
+  devices = g_ptr_array_new_with_free_func (g_object_unref);
+
+  if (priv->port == PP_HOST_UNSET_PORT)
+    port = PP_HOST_DEFAULT_IPP_PORT;
+  else
+    port = priv->port;
+
+  /* Connect to remote CUPS server and get its devices */
+#ifdef HAVE_CUPS_HTTPCONNECT2
+  http = httpConnect2 (priv->hostname, port, NULL, AF_UNSPEC,
+                       HTTP_ENCRYPTION_IF_REQUESTED, 1, 30000, NULL);
+#else
+  http = httpConnect (priv->hostname, port);
+#endif
+  if (http)
+    {
+      num_of_devices = cupsGetDests2 (http, &dests);
+      if (num_of_devices > 0)
+        {
+          for (i = 0; i < num_of_devices; i++)
+            {
+              g_autofree gchar *device_uri = NULL;
+              const char *device_location;
+              PpPrintDevice *device;
+
+              device_uri = g_strdup_printf ("ipp://%s:%d/printers/%s",
+                                            priv->hostname,
+                                            port,
+                                            dests[i].name);
+
+              device_location = cupsGetOption ("printer-location",
+                                               dests[i].num_options,
+                                               dests[i].options);
+
+              device = g_object_new (PP_TYPE_PRINT_DEVICE,
+                                     "is-network-device", TRUE,
+                                     "device-uri", device_uri,
+                                     "device-name", dests[i].name,
+                                     "device-location", device_location,
+                                     "host-name", priv->hostname,
+                                     "host-port", port,
+                                     "acquisition-method", ACQUISITION_METHOD_REMOTE_CUPS_SERVER,
+                                     NULL);
+              g_ptr_array_add (devices, device);
+            }
+        }
+
+      httpClose (http);
+    }
+
+  g_task_return_pointer (task, g_ptr_array_ref (devices), (GDestroyNotify) g_ptr_array_unref);
+}
+
+void
+pp_host_get_remote_cups_devices_async (PpHost              *self,
+                                       GCancellable        *cancellable,
+                                       GAsyncReadyCallback  callback,
+                                       gpointer             user_data)
+{
+  g_autoptr(GTask) task = NULL;
+
+  task = g_task_new (self, cancellable, callback, user_data);
+  g_task_run_in_thread (task, _pp_host_get_remote_cups_devices_thread);
+}
+
+GPtrArray *
+pp_host_get_remote_cups_devices_finish (PpHost        *self,
+                                        GAsyncResult  *res,
+                                        GError       **error)
+{
+  g_return_val_if_fail (g_task_is_valid (res, self), NULL);
+  g_return_val_if_fail (error == NULL || *error == NULL, NULL);
+  return g_task_propagate_pointer (G_TASK (res), error);
+}
+
+typedef struct
+{
+  PpHost *host;
+  gint    port;
+} JetDirectData;
+
+static void
+jetdirect_data_free (JetDirectData *data)
+{
+  if (data != NULL)
+    {
+      g_clear_object (&data->host);
+      g_free (data);
+    }
+}
+
+static void
+jetdirect_connection_test_cb (GObject      *source_object,
+                              GAsyncResult *res,
+                              gpointer      user_data)
+{
+  g_autoptr(GSocketConnection) connection = NULL;
+  PpHostPrivate               *priv;
+  JetDirectData               *data;
+  g_autoptr(GPtrArray)         devices = NULL;
+  g_autoptr(GError)            error = NULL;
+  g_autoptr(GTask)             task = G_TASK (user_data);
+
+  data = g_task_get_task_data (task);
+  priv = pp_host_get_instance_private (data->host);
+
+  devices = g_ptr_array_new_with_free_func (g_object_unref);
+
+  connection = g_socket_client_connect_to_host_finish (G_SOCKET_CLIENT (source_object),
+                                                       res,
+                                                       &error);
+
+  if (connection != NULL)
+    {
+      g_autofree gchar *device_uri = NULL;
+      PpPrintDevice *device;
+
+      g_io_stream_close (G_IO_STREAM (connection), NULL, NULL);
+
+      device_uri = g_strdup_printf ("socket://%s:%d",
+                                    priv->hostname,
+                                    data->port);
+
+      device = g_object_new (PP_TYPE_PRINT_DEVICE,
+                             "is-network-device", TRUE,
+                             "device-uri", device_uri,
+                             /* Translators: The found device is a JetDirect printer */
+                             "device-name", _("JetDirect Printer"),
+                             "host-name", priv->hostname,
+                             "host-port", data->port,
+                             "acquisition-method", ACQUISITION_METHOD_JETDIRECT,
+                             NULL);
+      g_ptr_array_add (devices, device);
+    }
+
+  g_task_return_pointer (task, g_ptr_array_ref (devices), (GDestroyNotify) g_ptr_array_unref);
+}
+
+/* Test whether given host has an AppSocket/HP JetDirect printer connected.
+   See http://en.wikipedia.org/wiki/JetDirect
+       http://www.cups.org/documentation.php/network.html */
+void
+pp_host_get_jetdirect_devices_async (PpHost              *self,
+                                     GCancellable        *cancellable,
+                                     GAsyncReadyCallback  callback,
+                                     gpointer             user_data)
+{
+  PpHostPrivate    *priv = pp_host_get_instance_private (self);
+  JetDirectData    *data;
+  g_autoptr(GTask)  task = NULL;
+  g_autofree gchar *address = NULL;
+
+  data = g_new0 (JetDirectData, 1);
+  data->host = g_object_ref (self);
+
+  if (priv->port == PP_HOST_UNSET_PORT)
+    data->port = PP_HOST_DEFAULT_JETDIRECT_PORT;
+  else
+    data->port = priv->port;
+
+  task = g_task_new (G_OBJECT (self), cancellable, callback, user_data);
+  g_task_set_task_data (task, data, (GDestroyNotify) jetdirect_data_free);
+
+  address = g_strdup_printf ("%s:%d", priv->hostname, data->port);
+  if (address != NULL && address[0] != '/')
+    {
+      g_autoptr(GSocketClient) client = NULL;
+
+      client = g_socket_client_new ();
+
+      g_socket_client_connect_to_host_async (client,
+                                             address,
+                                             data->port,
+                                             cancellable,
+                                             jetdirect_connection_test_cb,
+                                             g_steal_pointer (&task));
+    }
+  else
+    {
+      GPtrArray *devices = g_ptr_array_new_with_free_func (g_object_unref);
+      g_task_return_pointer (task, devices, (GDestroyNotify) g_ptr_array_unref);
+    }
+}
+
+GPtrArray *
+pp_host_get_jetdirect_devices_finish (PpHost        *self,
+                                      GAsyncResult  *res,
+                                      GError       **error)
+{
+  g_return_val_if_fail (g_task_is_valid (res, self), NULL);
+  g_return_val_if_fail (error == NULL || *error == NULL, NULL);
+  return g_task_propagate_pointer (G_TASK (res), error);
+}
+
+static gboolean
+test_lpd_queue (GSocketClient *client,
+                gchar         *address,
+                gint           port,
+                GCancellable  *cancellable,
+                gchar         *queue_name)
+{
+  g_autoptr(GSocketConnection) connection = NULL;
+  gboolean                     result = FALSE;
+  g_autoptr(GError)            error = NULL;
+
+  connection = g_socket_client_connect_to_host (client,
+                                                address,
+                                                port,
+                                                cancellable,
+                                                &error);
+
+  if (connection != NULL)
+    {
+      if (G_IS_TCP_CONNECTION (connection))
+        {
+          GOutputStream *output;
+          GInputStream  *input;
+          gssize         bytes_read, bytes_written;
+          gchar          buffer[BUFFER_LENGTH];
+          gint           length;
+
+          output = g_io_stream_get_output_stream (G_IO_STREAM (connection));
+          input = g_io_stream_get_input_stream (G_IO_STREAM (connection));
+
+          /* This LPD command is explained in RFC 1179, section 5.2 */
+          length = g_snprintf (buffer, BUFFER_LENGTH, "\2%s\n", queue_name);
+
+          bytes_written = g_output_stream_write (output,
+                                                 buffer,
+                                                 length,
+                                                 NULL,
+                                                 &error);
+
+          if (bytes_written != -1)
+            {
+              bytes_read = g_input_stream_read (input,
+                                                buffer,
+                                                BUFFER_LENGTH,
+                                                NULL,
+                                                &error);
+
+              if (bytes_read != -1)
+                {
+                  if (bytes_read > 0 && buffer[0] == 0)
+                    {
+                      /* This LPD command is explained in RFC 1179, section 6.1 */
+                      length = g_snprintf (buffer, BUFFER_LENGTH, "\1\n");
+
+                      bytes_written = g_output_stream_write (output,
+                                                             buffer,
+                                                             length,
+                                                             NULL,
+                                                             &error);
+
+                      result = TRUE;
+                    }
+                }
+            }
+        }
+
+      g_io_stream_close (G_IO_STREAM (connection), NULL, NULL);
+    }
+
+  return result;
+}
+
+static void
+_pp_host_get_lpd_devices_thread (GTask        *task,
+                                 gpointer      source_object,
+                                 gpointer      task_data,
+                                 GCancellable *cancellable)
+{
+  g_autoptr(GSocketConnection) connection = NULL;
+  PpHost                      *self = source_object;
+  PpHostPrivate               *priv = pp_host_get_instance_private (self);
+  g_autoptr(GPtrArray)         devices = NULL;
+  g_autoptr(GSocketClient)     client = NULL;
+  g_autoptr(GError)            error = NULL;
+  GList                       *candidates = NULL;
+  GList                       *iter;
+  gchar                       *found_queue = NULL;
+  gchar                       *candidate;
+  g_autofree gchar            *address = NULL;
+  gint                         port;
+  gint                         i;
+
+  if (priv->port == PP_HOST_UNSET_PORT)
+    port = PP_HOST_DEFAULT_LPD_PORT;
+  else
+    port = priv->port;
+
+  devices = g_ptr_array_new_with_free_func (g_object_unref);
+
+  address = g_strdup_printf ("%s:%d", priv->hostname, port);
+  if (address == NULL || address[0] == '/')
+    {
+      g_task_return_pointer (task, g_ptr_array_ref (devices), (GDestroyNotify) g_ptr_array_unref);
+      return;
+    }
+
+  client = g_socket_client_new ();
+
+  connection = g_socket_client_connect_to_host (client,
+                                                address,
+                                                port,
+                                                cancellable,
+                                                &error);
+
+  if (connection != NULL)
+    {
+      g_io_stream_close (G_IO_STREAM (connection), NULL, NULL);
+
+      /* Most of this list is taken from system-config-printer */
+      candidates = g_list_append (candidates, g_strdup ("PASSTHRU"));
+      candidates = g_list_append (candidates, g_strdup ("AUTO"));
+      candidates = g_list_append (candidates, g_strdup ("BINPS"));
+      candidates = g_list_append (candidates, g_strdup ("RAW"));
+      candidates = g_list_append (candidates, g_strdup ("TEXT"));
+      candidates = g_list_append (candidates, g_strdup ("ps"));
+      candidates = g_list_append (candidates, g_strdup ("lp"));
+      candidates = g_list_append (candidates, g_strdup ("PORT1"));
+
+      for (i = 0; i < 8; i++)
+        {
+          candidates = g_list_append (candidates, g_strdup_printf ("LPT%d", i));
+          candidates = g_list_append (candidates, g_strdup_printf ("LPT%d_PASSTHRU", i));
+          candidates = g_list_append (candidates, g_strdup_printf ("COM%d", i));
+          candidates = g_list_append (candidates, g_strdup_printf ("COM%d_PASSTHRU", i));
+        }
+
+      for (i = 0; i < 50; i++)
+        candidates = g_list_append (candidates, g_strdup_printf ("pr%d", i));
+
+      for (iter = candidates; iter != NULL; iter = iter->next)
+        {
+          candidate = (gchar *) iter->data;
+
+          if (test_lpd_queue (client,
+                              address,
+                              port,
+                              cancellable,
+                              candidate))
+            {
+              found_queue = g_strdup (candidate);
+              break;
+            }
+        }
+
+      if (found_queue != NULL)
+        {
+          g_autofree gchar *device_uri = NULL;
+          PpPrintDevice *device;
+
+          device_uri = g_strdup_printf ("lpd://%s:%d/%s",
+                                        priv->hostname,
+                                        port,
+                                        found_queue);
+
+          device = g_object_new (PP_TYPE_PRINT_DEVICE,
+                                 "is-network-device", TRUE,
+                                 "device-uri", device_uri,
+                                 /* Translators: The found device is a Line Printer Daemon printer */
+                                 "device-name", _("LPD Printer"),
+                                 "host-name", priv->hostname,
+                                 "host-port", port,
+                                 "acquisition-method", ACQUISITION_METHOD_LPD,
+                                 NULL);
+          g_ptr_array_add (devices, device);
+        }
+
+      g_list_free_full (candidates, g_free);
+    }
+
+  g_task_return_pointer (task, g_ptr_array_ref (devices), (GDestroyNotify) g_ptr_array_unref);
+}
+
+void
+pp_host_get_lpd_devices_async (PpHost              *self,
+                               GCancellable        *cancellable,
+                               GAsyncReadyCallback  callback,
+                               gpointer             user_data)
+{
+  g_autoptr(GTask) task = NULL;
+
+  task = g_task_new (G_OBJECT (self), cancellable, callback, user_data);
+  g_task_run_in_thread (task, _pp_host_get_lpd_devices_thread);
+}
+
+GPtrArray *
+pp_host_get_lpd_devices_finish (PpHost        *self,
+                                GAsyncResult  *res,
+                                GError       **error)
+{
+  g_return_val_if_fail (g_task_is_valid (res, self), NULL);
+  g_return_val_if_fail (error == NULL || *error == NULL, NULL);
+  return g_task_propagate_pointer (G_TASK (res), error);
+}
diff --git a/panels/printers/pp-host.h b/panels/printers/pp-host.h
new file mode 100644
index 0000000..3e29217
--- /dev/null
+++ b/panels/printers/pp-host.h
@@ -0,0 +1,80 @@
+/* -*- 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 2 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, see <http://www.gnu.org/licenses/>.
+ *
+ * Author: Marek Kasik <mkasik@redhat.com>
+ */
+
+#pragma once
+
+#include <glib-object.h>
+#include <gio/gio.h>
+#include "pp-utils.h"
+
+G_BEGIN_DECLS
+
+#define PP_TYPE_HOST (pp_host_get_type ())
+G_DECLARE_DERIVABLE_TYPE (PpHost, pp_host, PP, HOST, GObject)
+
+struct _PpHostClass
+{
+  GObjectClass parent_class;
+};
+
+#define PP_HOST_UNSET_PORT               -1
+#define PP_HOST_DEFAULT_IPP_PORT        631
+#define PP_HOST_DEFAULT_JETDIRECT_PORT 9100
+#define PP_HOST_DEFAULT_LPD_PORT        515
+
+PpHost        *pp_host_new                            (const gchar          *hostname);
+
+void           pp_host_get_snmp_devices_async         (PpHost               *host,
+                                                       GCancellable         *cancellable,
+                                                       GAsyncReadyCallback   callback,
+                                                       gpointer              user_data);
+
+GPtrArray     *pp_host_get_snmp_devices_finish        (PpHost               *host,
+                                                       GAsyncResult         *result,
+                                                       GError              **error);
+
+void           pp_host_get_remote_cups_devices_async  (PpHost               *host,
+                                                       GCancellable         *cancellable,
+                                                       GAsyncReadyCallback   callback,
+                                                       gpointer              user_data);
+
+GPtrArray     *pp_host_get_remote_cups_devices_finish (PpHost               *host,
+                                                       GAsyncResult         *result,
+                                                       GError              **error);
+
+void           pp_host_get_jetdirect_devices_async    (PpHost               *host,
+                                                       GCancellable         *cancellable,
+                                                       GAsyncReadyCallback   callback,
+                                                       gpointer              user_data);
+
+GPtrArray     *pp_host_get_jetdirect_devices_finish   (PpHost               *host,
+                                                       GAsyncResult         *result,
+                                                       GError              **error);
+
+void           pp_host_get_lpd_devices_async          (PpHost               *host,
+                                                       GCancellable         *cancellable,
+                                                       GAsyncReadyCallback   callback,
+                                                       gpointer              user_data);
+
+GPtrArray     *pp_host_get_lpd_devices_finish         (PpHost               *host,
+                                                       GAsyncResult         *result,
+                                                       GError              **error);
+
+G_END_DECLS
diff --git a/panels/printers/pp-ipp-option-widget.c b/panels/printers/pp-ipp-option-widget.c
new file mode 100644
index 0000000..ea27ad7
--- /dev/null
+++ b/panels/printers/pp-ipp-option-widget.c
@@ -0,0 +1,524 @@
+/* -*- 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 2 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, see <http://www.gnu.org/licenses/>.
+ *
+ * Author: Marek Kasik <mkasik@redhat.com>
+ */
+
+#include "config.h"
+#include <stdlib.h>
+#include <string.h>
+#include <stdio.h>
+#include <ctype.h>
+#include <glib/gi18n-lib.h>
+
+#include "pp-ipp-option-widget.h"
+#include "pp-utils.h"
+
+static void pp_ipp_option_widget_finalize (GObject *object);
+
+static gboolean construct_widget   (PpIPPOptionWidget *self);
+static void     update_widget      (PpIPPOptionWidget *self);
+static void     update_widget_real (PpIPPOptionWidget *self);
+
+struct _PpIPPOptionWidget
+{
+  GtkBox parent_instance;
+
+  GtkWidget *switch_button;
+  GtkWidget *spin_button;
+  GtkWidget *dropdown;
+
+  IPPAttribute *option_supported;
+  IPPAttribute *option_default;
+
+  gchar *printer_name;
+  gchar *option_name;
+
+  GHashTable *ipp_attribute;
+
+  GCancellable *cancellable;
+};
+
+G_DEFINE_TYPE (PpIPPOptionWidget, pp_ipp_option_widget, GTK_TYPE_BOX)
+
+static const struct {
+  const char *keyword;
+  const char *choice;
+  const char *translation;
+} ipp_choice_translations[] = {
+  /* Translators: this is an option of "Two Sided" */
+  { "sides", "one-sided", N_("One Sided") },
+  /* Translators: this is an option of "Two Sided" */
+  { "sides", "two-sided-long-edge", N_("Long Edge (Standard)") },
+  /* Translators: this is an option of "Two Sided" */
+  { "sides", "two-sided-short-edge", N_("Short Edge (Flip)") },
+  /* Translators: this is an option of "Orientation" */
+  { "orientation-requested", "3", N_("Portrait") },
+  /* Translators: this is an option of "Orientation" */
+  { "orientation-requested", "4", N_("Landscape") },
+  /* Translators: this is an option of "Orientation" */
+  { "orientation-requested", "5", N_("Reverse landscape") },
+  /* Translators: this is an option of "Orientation" */
+  { "orientation-requested", "6", N_("Reverse portrait") },
+};
+
+static const gchar *
+ipp_choice_translate (const gchar *option,
+                      const gchar *choice)
+{
+  gint i;
+
+  for (i = 0; i < G_N_ELEMENTS (ipp_choice_translations); i++)
+    {
+      if (g_strcmp0 (ipp_choice_translations[i].keyword, option) == 0 &&
+          g_strcmp0 (ipp_choice_translations[i].choice, choice) == 0)
+        {
+          return _(ipp_choice_translations[i].translation);
+        }
+    }
+
+  return choice;
+}
+
+static void
+pp_ipp_option_widget_class_init (PpIPPOptionWidgetClass *class)
+{
+  GObjectClass *object_class;
+
+  object_class = G_OBJECT_CLASS (class);
+
+  object_class->finalize = pp_ipp_option_widget_finalize;
+}
+
+static void
+pp_ipp_option_widget_init (PpIPPOptionWidget *self)
+{
+  gtk_orientable_set_orientation (GTK_ORIENTABLE (self),
+                                  GTK_ORIENTATION_HORIZONTAL);
+}
+
+static void
+pp_ipp_option_widget_finalize (GObject *object)
+{
+  PpIPPOptionWidget *self = PP_IPP_OPTION_WIDGET (object);
+
+  g_cancellable_cancel (self->cancellable);
+
+  g_clear_pointer (&self->option_name, g_free);
+  g_clear_pointer (&self->printer_name, g_free);
+  g_clear_pointer (&self->option_supported, ipp_attribute_free);
+  g_clear_pointer (&self->option_default, ipp_attribute_free);
+  g_clear_pointer (&self->ipp_attribute, g_hash_table_unref);
+  g_clear_object (&self->cancellable);
+
+  G_OBJECT_CLASS (pp_ipp_option_widget_parent_class)->finalize (object);
+}
+
+GtkWidget *
+pp_ipp_option_widget_new (IPPAttribute *attr_supported,
+                          IPPAttribute *attr_default,
+                          const gchar  *option_name,
+                          const gchar  *printer)
+{
+  PpIPPOptionWidget *self = NULL;
+
+  if (attr_supported && option_name && printer)
+    {
+      self = g_object_new (PP_TYPE_IPP_OPTION_WIDGET, NULL);
+
+      self->printer_name = g_strdup (printer);
+      self->option_name = g_strdup (option_name);
+      self->option_supported = ipp_attribute_copy (attr_supported);
+      self->option_default = ipp_attribute_copy (attr_default);
+
+      if (construct_widget (self))
+        {
+          update_widget_real (self);
+        }
+      else
+        {
+          g_object_ref_sink (self);
+          g_object_unref (self);
+          self = NULL;
+        }
+    }
+
+  return (GtkWidget *) self;
+}
+
+static GtkWidget *
+dropdown_new (void)
+{
+  GtkStringList *store = NULL;
+  GtkWidget     *dropdown;
+
+  store = gtk_string_list_new (NULL);
+
+  dropdown = gtk_drop_down_new (G_LIST_MODEL (store), NULL);
+
+  return dropdown;
+}
+
+static void
+dropdown_append (GtkWidget   *dropdown,
+                 const gchar *display_text)
+{
+  GtkStringList *store;
+
+  store = GTK_STRING_LIST (gtk_drop_down_get_model (GTK_DROP_DOWN (dropdown)));
+
+  gtk_string_list_append (store, display_text);
+}
+
+static void
+dropdown_set (GtkWidget    *dropdown,
+              IPPAttribute *option,
+              const gchar  *value)
+{
+  g_autofree gchar *attribute_value = NULL;
+
+  for (guint i = 0; i < option->num_of_values; i++)
+    {
+      if (option->attribute_type == IPP_ATTRIBUTE_TYPE_INTEGER)
+        attribute_value = g_strdup_printf ("%d", option->attribute_values[i].integer_value);
+      else
+        attribute_value = g_strdup (option->attribute_values[i].string_value);
+
+      if (g_strcmp0 (attribute_value, value) == 0)
+        {
+          gtk_drop_down_set_selected (GTK_DROP_DOWN (dropdown), i);
+          break;
+        }
+    }
+}
+
+static char *
+dropdown_get (GtkWidget    *dropdown,
+              IPPAttribute *option)
+{
+  guint          selected_item;
+  gchar         *value = NULL;
+
+  selected_item = gtk_drop_down_get_selected (GTK_DROP_DOWN (dropdown));
+
+  if (selected_item != GTK_INVALID_LIST_POSITION)
+    {
+      if (option->attribute_type == IPP_ATTRIBUTE_TYPE_INTEGER)
+        value = g_strdup_printf ("%d", option->attribute_values[selected_item].integer_value);
+      else
+        value = option->attribute_values[selected_item].string_value;
+    }
+
+  return value;
+}
+
+static void
+printer_add_option_async_cb (gboolean success,
+                             gpointer user_data)
+{
+  PpIPPOptionWidget *self = user_data;
+
+  update_widget (user_data);
+  g_clear_object (&self->cancellable);
+}
+
+static void
+switch_changed_cb (PpIPPOptionWidget *self)
+{
+  gchar                    **values;
+
+  values = g_new0 (gchar *, 2);
+
+  if (gtk_switch_get_active (GTK_SWITCH (self->switch_button)))
+    values[0] = g_strdup ("True");
+  else
+    values[0] = g_strdup ("False");
+
+  g_cancellable_cancel (self->cancellable);
+  g_clear_object (&self->cancellable);
+
+  self->cancellable = g_cancellable_new ();
+  printer_add_option_async (self->printer_name,
+                            self->option_name,
+                            values,
+                            TRUE,
+                            self->cancellable,
+                            printer_add_option_async_cb,
+                            self);
+
+  g_strfreev (values);
+}
+
+static void
+dropdown_changed_cb (PpIPPOptionWidget *self)
+{
+  gchar                    **values;
+
+  values = g_new0 (gchar *, 2);
+  values[0] = g_strdup (dropdown_get (self->dropdown, self->option_supported));
+
+  g_cancellable_cancel (self->cancellable);
+  g_clear_object (&self->cancellable);
+
+  self->cancellable = g_cancellable_new ();
+  printer_add_option_async (self->printer_name,
+                            self->option_name,
+                            values,
+                            TRUE,
+                            self->cancellable,
+                            printer_add_option_async_cb,
+                            self);
+
+  g_strfreev (values);
+}
+
+static void
+spin_button_changed_cb (PpIPPOptionWidget *self)
+{
+  gchar                    **values;
+
+  values = g_new0 (gchar *, 2);
+  values[0] = g_strdup_printf ("%d", gtk_spin_button_get_value_as_int (GTK_SPIN_BUTTON (self->spin_button)));
+
+  g_cancellable_cancel (self->cancellable);
+  g_clear_object (&self->cancellable);
+
+  self->cancellable = g_cancellable_new ();
+  printer_add_option_async (self->printer_name,
+                            self->option_name,
+                            values,
+                            TRUE,
+                            self->cancellable,
+                            printer_add_option_async_cb,
+                            self);
+
+  g_strfreev (values);
+}
+
+static gboolean
+construct_widget (PpIPPOptionWidget *self)
+{
+  gboolean                  trivial_option = FALSE;
+  gboolean                  result = FALSE;
+  gint                      i;
+
+  if (self->option_supported)
+    {
+      switch (self->option_supported->attribute_type)
+        {
+          case IPP_ATTRIBUTE_TYPE_INTEGER:
+            if (self->option_supported->num_of_values <= 1)
+              trivial_option = TRUE;
+            break;
+
+          case IPP_ATTRIBUTE_TYPE_STRING:
+            if (self->option_supported->num_of_values <= 1)
+              trivial_option = TRUE;
+            break;
+
+          case IPP_ATTRIBUTE_TYPE_RANGE:
+            if (self->option_supported->attribute_values[0].lower_range ==
+                self->option_supported->attribute_values[0].upper_range)
+              trivial_option = TRUE;
+            break;
+        }
+
+      if (!trivial_option)
+        {
+          switch (self->option_supported->attribute_type)
+            {
+              case IPP_ATTRIBUTE_TYPE_BOOLEAN:
+                  self->switch_button = gtk_switch_new ();
+
+                  gtk_box_append (GTK_BOX (self), self->switch_button);
+                  g_signal_connect_object (self->switch_button, "notify::active", G_CALLBACK (switch_changed_cb), self, G_CONNECT_SWAPPED);
+                  break;
+
+              case IPP_ATTRIBUTE_TYPE_INTEGER:
+                  self->dropdown = dropdown_new ();
+
+                  for (i = 0; i < self->option_supported->num_of_values; i++)
+                    {
+                      g_autofree gchar *value = NULL;
+
+                      value = g_strdup_printf ("%d", self->option_supported->attribute_values[i].integer_value);
+                      dropdown_append (self->dropdown,
+                                       ipp_choice_translate (self->option_name,
+                                                             value));
+                    }
+
+                  gtk_box_append (GTK_BOX (self), self->dropdown);
+                  g_signal_connect_object (self->dropdown, "notify::selected", G_CALLBACK (dropdown_changed_cb), self, G_CONNECT_SWAPPED);
+                  break;
+
+              case IPP_ATTRIBUTE_TYPE_STRING:
+                  self->dropdown = dropdown_new ();
+
+                  for (i = 0; i < self->option_supported->num_of_values; i++)
+                    dropdown_append (self->dropdown,
+                                     ipp_choice_translate (self->option_name,
+                                                           self->option_supported->attribute_values[i].string_value));
+
+                  gtk_box_append (GTK_BOX (self), self->dropdown);
+                  g_signal_connect_object (self->dropdown, "notify::selected", G_CALLBACK (dropdown_changed_cb), self, G_CONNECT_SWAPPED);
+                  break;
+
+              case IPP_ATTRIBUTE_TYPE_RANGE:
+                  self->spin_button = gtk_spin_button_new_with_range (
+                                        self->option_supported->attribute_values[0].lower_range,
+                                        self->option_supported->attribute_values[0].upper_range,
+                                        1);
+
+                  gtk_box_append (GTK_BOX (self), self->spin_button);
+                  g_signal_connect_object (self->spin_button, "value-changed", G_CALLBACK (spin_button_changed_cb), self, G_CONNECT_SWAPPED);
+                  break;
+
+              default:
+                  break;
+            }
+
+          result = TRUE;
+        }
+    }
+
+  return result;
+}
+
+static void
+update_widget_real (PpIPPOptionWidget *self)
+{
+  IPPAttribute             *attr = NULL;
+
+  if (self->option_default)
+    {
+      attr = ipp_attribute_copy (self->option_default);
+
+      ipp_attribute_free (self->option_default);
+      self->option_default = NULL;
+    }
+  else if (self->ipp_attribute)
+    {
+      g_autofree gchar *attr_name = g_strdup_printf ("%s-default", self->option_name);
+      attr = ipp_attribute_copy (g_hash_table_lookup (self->ipp_attribute, attr_name));
+
+      g_hash_table_unref (self->ipp_attribute);
+      self->ipp_attribute = NULL;
+    }
+
+  switch (self->option_supported->attribute_type)
+    {
+      case IPP_ATTRIBUTE_TYPE_BOOLEAN:
+        g_signal_handlers_block_by_func (self->switch_button, switch_changed_cb, self);
+
+        if (attr && attr->num_of_values > 0 &&
+            attr->attribute_type == IPP_ATTRIBUTE_TYPE_BOOLEAN)
+          {
+            gtk_switch_set_active (GTK_SWITCH (self->switch_button),
+                                   attr->attribute_values[0].boolean_value);
+          }
+
+        g_signal_handlers_unblock_by_func (self->switch_button, switch_changed_cb, self);
+        break;
+
+      case IPP_ATTRIBUTE_TYPE_INTEGER:
+        g_signal_handlers_block_by_func (self->dropdown, dropdown_changed_cb, self);
+
+        if (attr && attr->num_of_values > 0 &&
+            attr->attribute_type == IPP_ATTRIBUTE_TYPE_INTEGER)
+          {
+            g_autofree gchar *value = g_strdup_printf ("%d", attr->attribute_values[0].integer_value);
+            dropdown_set (self->dropdown, self->option_supported, value);
+          }
+        else
+          {
+            g_autofree gchar *value = g_strdup_printf ("%d", self->option_supported->attribute_values[0].integer_value);
+            dropdown_set (self->dropdown, self->option_supported, value);
+          }
+
+        g_signal_handlers_unblock_by_func (self->dropdown, dropdown_changed_cb, self);
+        break;
+
+      case IPP_ATTRIBUTE_TYPE_STRING:
+        g_signal_handlers_block_by_func (self->dropdown, dropdown_changed_cb, self);
+
+        if (attr && attr->num_of_values > 0 &&
+            attr->attribute_type == IPP_ATTRIBUTE_TYPE_STRING)
+          {
+            dropdown_set (self->dropdown, self->option_supported, attr->attribute_values[0].string_value);
+          }
+        else
+          {
+            dropdown_set (self->dropdown, self->option_supported, self->option_supported->attribute_values[0].string_value);
+          }
+
+        g_signal_handlers_unblock_by_func (self->dropdown, dropdown_changed_cb, self);
+        break;
+
+      case IPP_ATTRIBUTE_TYPE_RANGE:
+        g_signal_handlers_block_by_func (self->spin_button, spin_button_changed_cb, self);
+
+        if (attr && attr->num_of_values > 0 &&
+            attr->attribute_type == IPP_ATTRIBUTE_TYPE_INTEGER)
+          {
+            gtk_spin_button_set_value (GTK_SPIN_BUTTON (self->spin_button),
+                                       attr->attribute_values[0].integer_value);
+          }
+        else
+          {
+            gtk_spin_button_set_value (GTK_SPIN_BUTTON (self->spin_button),
+                                       self->option_supported->attribute_values[0].lower_range);
+          }
+
+        g_signal_handlers_unblock_by_func (self->spin_button, spin_button_changed_cb, self);
+        break;
+
+      default:
+        break;
+    }
+
+  ipp_attribute_free (attr);
+}
+
+static void
+get_ipp_attributes_cb (GHashTable *table,
+                       gpointer    user_data)
+{
+  PpIPPOptionWidget *self = user_data;
+
+  if (self->ipp_attribute)
+    g_hash_table_unref (self->ipp_attribute);
+
+  self->ipp_attribute = g_hash_table_ref (table);
+
+  update_widget_real (self);
+}
+
+static void
+update_widget (PpIPPOptionWidget *self)
+{
+  gchar                    **attributes_names;
+
+  attributes_names = g_new0 (gchar *, 2);
+  attributes_names[0] = g_strdup_printf ("%s-default", self->option_name);
+
+  get_ipp_attributes_async (self->printer_name,
+                            attributes_names,
+                            get_ipp_attributes_cb,
+                            self);
+
+  g_strfreev (attributes_names);
+}
diff --git a/panels/printers/pp-ipp-option-widget.h b/panels/printers/pp-ipp-option-widget.h
new file mode 100644
index 0000000..a5d0b84
--- /dev/null
+++ b/panels/printers/pp-ipp-option-widget.h
@@ -0,0 +1,39 @@
+/* -*- 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 2 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, see <http://www.gnu.org/licenses/>.
+ *
+ * Author: Marek Kasik <mkasik@redhat.com>
+ */
+
+#pragma once
+
+#include <gtk/gtk.h>
+#include <cups/cups.h>
+#include <cups/ppd.h>
+
+#include "pp-utils.h"
+
+G_BEGIN_DECLS
+
+#define PP_TYPE_IPP_OPTION_WIDGET (pp_ipp_option_widget_get_type ())
+G_DECLARE_FINAL_TYPE (PpIPPOptionWidget, pp_ipp_option_widget, PP, IPP_OPTION_WIDGET, GtkBox)
+
+GtkWidget   *pp_ipp_option_widget_new (IPPAttribute *attr_supported,
+                                       IPPAttribute *attr_default,
+                                       const gchar  *option_name,
+                                       const gchar  *printer);
+
+G_END_DECLS
diff --git a/panels/printers/pp-job-row.c b/panels/printers/pp-job-row.c
new file mode 100644
index 0000000..6b1fe27
--- /dev/null
+++ b/panels/printers/pp-job-row.c
@@ -0,0 +1,190 @@
+/* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 8 -*-
+ *
+ * Copyright 2020 Canonical Ltd.
+ *
+ * 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, see <http://www.gnu.org/licenses/>.
+ *
+ * SPDX-License-Identifier: GPL-3.0-or-later
+ */
+
+#include <config.h>
+#include <glib/gi18n.h>
+
+#include "pp-job-row.h"
+#include "cc-printers-resources.h"
+
+struct _PpJobRow
+{
+  GtkListBoxRow parent;
+
+  GtkButton *pause_button;
+  GtkButton *priority_button;
+  GtkLabel  *state_label;
+  GtkLabel  *title_label;
+
+  PpJob *job;
+};
+
+G_DEFINE_TYPE (PpJobRow, pp_job_row, GTK_TYPE_LIST_BOX_ROW)
+
+enum {
+  PRIORITY_CHANGED,
+  LAST_SIGNAL,
+};
+
+static guint signals[LAST_SIGNAL] = { 0 };
+
+static void
+update_pause_button (PpJobRow *self, gboolean paused)
+{
+  gtk_button_set_icon_name (self->pause_button,
+                            paused ? "media-playback-start-symbolic" : "media-playback-pause-symbolic");
+  gtk_accessible_update_property (GTK_ACCESSIBLE (self->pause_button),
+                                  GTK_ACCESSIBLE_PROPERTY_LABEL,
+                                  paused ? _("Resume") : _("Pause"),
+                                  -1);
+}
+
+static void
+pause_cb (PpJobRow *self)
+{
+  pp_job_set_hold_until_async (self->job, pp_job_get_state (self->job) == IPP_JOB_HELD ? "no-hold" : "indefinite");
+  update_pause_button (self,
+                       pp_job_get_state (self->job) == IPP_JOB_HELD);
+                                              }
+
+static void
+stop_cb (PpJobRow *self)
+{
+  pp_job_cancel_purge_async (self->job, FALSE);
+}
+
+static void
+priority_cb (PpJobRow *self)
+{
+  g_signal_emit_by_name (self, "priority-changed");
+}
+
+static void
+pp_job_row_dispose (GObject *object)
+{
+  PpJobRow *self = PP_JOB_ROW (object);
+
+  g_clear_object (&self->job);
+
+  G_OBJECT_CLASS (pp_job_row_parent_class)->dispose (object);
+}
+
+static void
+pp_job_row_class_init (PpJobRowClass *klass)
+{
+  GObjectClass *object_class = G_OBJECT_CLASS (klass);
+  GtkWidgetClass *widget_class = GTK_WIDGET_CLASS (klass);
+
+  object_class->dispose = pp_job_row_dispose;
+
+  gtk_widget_class_set_template_from_resource (widget_class, "/org/gnome/control-center/printers/pp-job-row.ui");
+
+  gtk_widget_class_bind_template_child (widget_class, PpJobRow, pause_button);
+  gtk_widget_class_bind_template_child (widget_class, PpJobRow, priority_button);
+  gtk_widget_class_bind_template_child (widget_class, PpJobRow, state_label);
+  gtk_widget_class_bind_template_child (widget_class, PpJobRow, title_label);
+
+  gtk_widget_class_bind_template_callback (widget_class, pause_cb);
+  gtk_widget_class_bind_template_callback (widget_class, stop_cb);
+  gtk_widget_class_bind_template_callback (widget_class, priority_cb);
+
+  signals[PRIORITY_CHANGED] =
+    g_signal_new ("priority-changed",
+                  G_TYPE_FROM_CLASS (klass),
+                  G_SIGNAL_RUN_LAST,
+                  0,
+                  NULL, NULL, NULL,
+                  G_TYPE_NONE, 0);
+}
+
+static void
+pp_job_row_init (PpJobRow *self)
+{
+  gtk_widget_init_template (GTK_WIDGET (self));
+}
+
+PpJob *
+pp_job_row_get_job (PpJobRow *self)
+{
+  return self->job;
+}
+
+PpJobRow *
+pp_job_row_new (PpJob *job)
+{
+  PpJobRow *self;
+  gboolean  status;
+  g_autofree gchar *state_string = NULL;
+
+  self = g_object_new (PP_TYPE_JOB_ROW, NULL);
+
+  self->job = g_object_ref (job);
+
+  switch (pp_job_get_state (job))
+    {
+      case IPP_JOB_PENDING:
+        /* Translators: Job's state (job is waiting to be printed) */
+        state_string = g_strdup (C_("print job", "Pending"));
+        break;
+      case IPP_JOB_HELD:
+        if (pp_job_get_auth_info_required (job) == NULL)
+          {
+            /* Translators: Job's state (job is held for printing) */
+            state_string = g_strdup (C_("print job", "Paused"));
+          }
+        else
+          {
+            /* Translators: Job's state (job needs authentication to proceed further) */
+            state_string = g_strdup_printf ("<span foreground=\"#ff0000\">%s</span>", C_("print job", "Authentication required"));
+          }
+        break;
+      case IPP_JOB_PROCESSING:
+        /* Translators: Job's state (job is currently printing) */
+        state_string = g_strdup (C_("print job", "Processing"));
+        break;
+      case IPP_JOB_STOPPED:
+        /* Translators: Job's state (job has been stopped) */
+        state_string = g_strdup (C_("print job", "Stopped"));
+        break;
+      case IPP_JOB_CANCELED:
+        /* Translators: Job's state (job has been canceled) */
+        state_string = g_strdup (C_("print job", "Canceled"));
+        break;
+      case IPP_JOB_ABORTED:
+        /* Translators: Job's state (job has aborted due to error) */
+        state_string = g_strdup (C_("print job", "Aborted"));
+        break;
+      case IPP_JOB_COMPLETED:
+        /* Translators: Job's state (job has completed successfully) */
+        state_string = g_strdup (C_("print job", "Completed"));
+        break;
+    }
+  gtk_label_set_text (self->title_label, pp_job_get_title (job));
+  gtk_label_set_markup (self->state_label, state_string);
+  gtk_widget_set_sensitive (GTK_WIDGET (self->pause_button), pp_job_get_auth_info_required (job) == NULL);
+  status = pp_job_priority_get_sensitive (job);
+  gtk_widget_set_sensitive (GTK_WIDGET (self->priority_button), status);
+  if (status)
+    /* Translators: Clicking this button prioritizes printing of this print job */
+    gtk_widget_set_tooltip_text (GTK_WIDGET (self->priority_button), _("Move this job to the top of the queue"));
+  update_pause_button (self,
+                       pp_job_get_state (self->job) == IPP_JOB_HELD);
+  return self;
+}
diff --git a/panels/printers/pp-job-row.h b/panels/printers/pp-job-row.h
new file mode 100644
index 0000000..088d7ff
--- /dev/null
+++ b/panels/printers/pp-job-row.h
@@ -0,0 +1,36 @@
+/* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 8 -*-
+ *
+ * Copyright 2020 Canonical Ltd.
+ *
+ * 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, see <http://www.gnu.org/licenses/>.
+ *
+ * SPDX-License-Identifier: GPL-3.0-or-later
+ */
+
+#pragma once
+
+#include <gtk/gtk.h>
+
+#include "pp-job.h"
+
+G_BEGIN_DECLS
+
+#define PP_TYPE_JOB_ROW (pp_job_row_get_type())
+G_DECLARE_FINAL_TYPE (PpJobRow, pp_job_row, PP, JOB_ROW, GtkListBoxRow)
+
+PpJobRow* pp_job_row_new     (PpJob    *job);
+
+PpJob*    pp_job_row_get_job (PpJobRow *self);
+
+G_END_DECLS
diff --git a/panels/printers/pp-job-row.ui b/panels/printers/pp-job-row.ui
new file mode 100644
index 0000000..0db47d7
--- /dev/null
+++ b/panels/printers/pp-job-row.ui
@@ -0,0 +1,62 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<interface>
+  <template class="PpJobRow" parent="GtkListBoxRow">
+    <child>
+      <object class="GtkBox">
+        <property name="margin-top">6</property>
+        <property name="margin-bottom">6</property>
+        <property name="margin-start">6</property>
+        <property name="margin-end">6</property>
+        <child>
+          <object class="GtkLabel" id="title_label">
+            <property name="ellipsize">end</property>
+            <property name="max-width-chars">40</property>
+            <property name="halign">start</property>
+            <property name="hexpand">True</property>
+            <property name="margin-start">10</property>
+            <property name="margin-end">10</property>
+          </object>
+        </child>
+        <child>
+          <object class="GtkLabel" id="state_label">
+            <property name="halign">end</property>
+            <property name="margin-start">74</property>
+            <property name="margin-end">74</property>
+          </object>
+        </child>
+        <child>
+          <object class="GtkButton" id="priority_button">
+            <property name="margin-start">4</property>
+            <property name="margin-end">4</property>
+            <property name="icon-name">go-top-symbolic</property>
+            <signal name="clicked" handler="priority_cb" object="PpJobRow" swapped="yes" />
+            <style>
+              <class name="image-button"/>
+            </style>
+          </object>
+        </child>
+        <child>
+          <object class="GtkButton" id="pause_button">
+            <property name="margin-start">4</property>
+            <property name="margin-end">4</property>
+            <signal name="clicked" handler="pause_cb" object="PpJobRow" swapped="yes" />
+            <style>
+              <class name="image-button"/>
+            </style>
+          </object>
+        </child>
+        <child>
+          <object class="GtkButton">
+            <property name="margin-start">4</property>
+            <property name="margin-end">4</property>
+            <property name="icon-name">edit-delete-symbolic</property>
+            <signal name="clicked" handler="stop_cb" object="PpJobRow" swapped="yes" />
+            <style>
+              <class name="image-button"/>
+            </style>
+          </object>
+        </child>
+      </object>
+    </child>
+  </template>
+</interface>
diff --git a/panels/printers/pp-job.c b/panels/printers/pp-job.c
new file mode 100644
index 0000000..68ceb6b
--- /dev/null
+++ b/panels/printers/pp-job.c
@@ -0,0 +1,485 @@
+/* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 8 -*-
+ *
+ * Copyright 2015  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 2 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, see <http://www.gnu.org/licenses/>.
+ *
+ * Author: Felipe Borges <feborges@redhat.com>
+ */
+
+#include "pp-job.h"
+
+#include <gio/gio.h>
+#include <cups/cups.h>
+
+#if (CUPS_VERSION_MAJOR > 1) || (CUPS_VERSION_MINOR > 5)
+#define HAVE_CUPS_1_6 1
+#endif
+
+#ifndef HAVE_CUPS_1_6
+#define ippGetBoolean(attr, element) attr->values[element].boolean
+#define ippGetCount(attr)     attr->num_values
+#define ippGetInteger(attr, element) attr->values[element].integer
+#define ippGetString(attr, element, language) attr->values[element].string.text
+#define ippGetValueTag(attr)  attr->value_tag
+static int
+ippGetRange (ipp_attribute_t *attr,
+             int element,
+             int *upper)
+{
+  *upper = attr->values[element].range.upper;
+  return (attr->values[element].range.lower);
+}
+#endif
+
+struct _PpJob
+{
+  GObject parent_instance;
+
+  gint     id;
+  gchar   *title;
+  gint     state;
+  gint     priority;
+  gboolean sensitive;
+
+  GStrv   auth_info_required;
+};
+
+G_DEFINE_TYPE (PpJob, pp_job, G_TYPE_OBJECT)
+
+static void
+pp_job_cancel_purge_async_dbus_cb (GObject      *source_object,
+                                   GAsyncResult *res,
+                                   gpointer      user_data)
+{
+  g_autoptr(GVariant) output = NULL;
+
+  output = g_dbus_connection_call_finish (G_DBUS_CONNECTION (source_object),
+                                          res,
+                                          NULL);
+}
+
+PpJob *
+pp_job_new (gint id, const gchar *title, gint state, gint priority, GStrv auth_info_required)
+{
+   PpJob *job = g_object_new (pp_job_get_type (), NULL);
+
+   job->id = id;
+   job->title = g_strdup (title);
+   job->state = state;
+   job->priority = priority;
+   job->sensitive = FALSE;
+   job->auth_info_required = g_strdupv (auth_info_required);
+
+   return job;
+}
+
+const gchar *
+pp_job_get_title (PpJob *self)
+{
+   g_return_val_if_fail (PP_IS_JOB(self), NULL);
+   return self->title;
+}
+
+gint
+pp_job_get_state (PpJob *self)
+{
+   g_return_val_if_fail (PP_IS_JOB(self), -1);
+   return self->state;
+}
+
+void
+pp_job_priority_set_sensitive (PpJob    *self,
+                               gboolean  sensitive)
+{
+   self->sensitive = sensitive;
+}
+
+gboolean
+pp_job_priority_get_sensitive (PpJob *self)
+{
+   g_return_val_if_fail (PP_IS_JOB (self), FALSE);
+   return self->sensitive;
+}
+
+gint
+pp_job_get_priority (PpJob *self)
+{
+   g_return_val_if_fail (PP_IS_JOB (self), -1);
+   return self->priority;
+}
+
+void
+pp_job_set_priority (PpJob *self,
+                     gint   priority)
+{
+   self->priority = priority;
+}
+
+GStrv
+pp_job_get_auth_info_required (PpJob *self)
+{
+   g_return_val_if_fail (PP_IS_JOB(self), NULL);
+   return self->auth_info_required;
+}
+
+void
+pp_job_cancel_purge_async (PpJob        *self,
+                           gboolean      job_purge)
+{
+  g_autoptr(GDBusConnection) bus = NULL;
+  g_autoptr(GError) error = NULL;
+
+  bus = g_bus_get_sync (G_BUS_TYPE_SYSTEM, NULL, &error);
+  if (!bus)
+    {
+      g_warning ("Failed to get session bus: %s", error->message);
+      return;
+    }
+
+  g_dbus_connection_call (bus,
+                          MECHANISM_BUS,
+                          "/",
+                          MECHANISM_BUS,
+                          "JobCancelPurge",
+                          g_variant_new ("(ib)",
+                                         self->id,
+                                         job_purge),
+                          G_VARIANT_TYPE ("(s)"),
+                          G_DBUS_CALL_FLAGS_NONE,
+                          -1,
+                          NULL,
+                          pp_job_cancel_purge_async_dbus_cb,
+                          NULL);
+}
+
+static void
+pp_job_set_hold_until_async_dbus_cb (GObject      *source_object,
+                                     GAsyncResult *res,
+                                     gpointer      user_data)
+{
+  g_autoptr(GVariant) output = NULL;
+
+  output = g_dbus_connection_call_finish (G_DBUS_CONNECTION (source_object),
+                                          res,
+                                          NULL);
+}
+
+void
+pp_job_set_hold_until_async (PpJob        *self,
+                             const gchar  *job_hold_until)
+{
+  g_autoptr(GDBusConnection) bus = NULL;
+  g_autoptr(GError) error = NULL;
+
+  bus = g_bus_get_sync (G_BUS_TYPE_SYSTEM, NULL, &error);
+  if (!bus)
+    {
+      g_warning ("Failed to get session bus: %s", error->message);
+      return;
+    }
+
+  g_dbus_connection_call (bus,
+                          MECHANISM_BUS,
+                          "/",
+                          MECHANISM_BUS,
+                          "JobSetHoldUntil",
+                          g_variant_new ("(is)",
+                                         self->id,
+                                         job_hold_until),
+                          G_VARIANT_TYPE ("(s)"),
+                          G_DBUS_CALL_FLAGS_NONE,
+                          -1,
+                          NULL,
+                          pp_job_set_hold_until_async_dbus_cb,
+                          NULL);
+}
+
+static void
+pp_job_init (PpJob *obj)
+{
+}
+
+static void
+pp_job_finalize (GObject *object)
+{
+  PpJob *self = PP_JOB (object);
+
+  g_clear_pointer (&self->title, g_free);
+  g_clear_pointer (&self->auth_info_required, g_strfreev);
+
+  G_OBJECT_CLASS (pp_job_parent_class)->finalize (object);
+}
+
+static void
+pp_job_class_init (PpJobClass *class)
+{
+  GObjectClass *object_class = G_OBJECT_CLASS (class);
+
+  object_class->finalize = pp_job_finalize;
+}
+
+static void
+_pp_job_get_attributes_thread (GTask        *task,
+                               gpointer      source_object,
+                               gpointer      task_data,
+                               GCancellable *cancellable)
+{
+  PpJob *self = PP_JOB (source_object);
+  ipp_attribute_t  *attr = NULL;
+  GVariantBuilder   builder;
+  GVariant         *attributes = NULL;
+  gchar           **attributes_names = task_data;
+  ipp_t            *request;
+  ipp_t            *response = NULL;
+  g_autofree gchar *job_uri = NULL;
+  gint              i, j, length = 0, n_attrs = 0;
+
+  job_uri = g_strdup_printf ("ipp://localhost/jobs/%d", self->id);
+
+  if (attributes_names != NULL)
+    {
+      length = g_strv_length (attributes_names);
+
+      request = ippNewRequest (IPP_GET_JOB_ATTRIBUTES);
+      ippAddString (request, IPP_TAG_OPERATION, IPP_TAG_URI,
+                    "job-uri", NULL, job_uri);
+      ippAddString (request, IPP_TAG_OPERATION, IPP_TAG_NAME,
+                    "requesting-user-name", NULL, cupsUser ());
+      ippAddStrings (request, IPP_TAG_OPERATION, IPP_TAG_KEYWORD,
+                     "requested-attributes", length, NULL, (const char **) attributes_names);
+      response = cupsDoRequest (CUPS_HTTP_DEFAULT, request, "/");
+    }
+
+  if (response != NULL)
+    {
+      g_variant_builder_init (&builder, G_VARIANT_TYPE ("a{sv}"));
+
+      for (j = 0; j < length; j++)
+        {
+          attr = ippFindAttribute (response, attributes_names[j], IPP_TAG_ZERO);
+          n_attrs = ippGetCount (attr);
+          if (attr != NULL && n_attrs > 0 && ippGetValueTag (attr) != IPP_TAG_NOVALUE)
+            {
+              const GVariantType  *type = NULL;
+              GVariant           **values;
+              GVariant            *range[2];
+              gint                 range_uppervalue;
+
+              values = g_new (GVariant*, n_attrs);
+
+              switch (ippGetValueTag (attr))
+                {
+                  case IPP_TAG_INTEGER:
+                  case IPP_TAG_ENUM:
+                    type = G_VARIANT_TYPE_INT32;
+
+                    for (i = 0; i < n_attrs; i++)
+                      values[i] = g_variant_new_int32 (ippGetInteger (attr, i));
+                    break;
+
+                  case IPP_TAG_NAME:
+                  case IPP_TAG_STRING:
+                  case IPP_TAG_TEXT:
+                  case IPP_TAG_URI:
+                  case IPP_TAG_KEYWORD:
+                  case IPP_TAG_URISCHEME:
+                    type = G_VARIANT_TYPE_STRING;
+
+                    for (i = 0; i < n_attrs; i++)
+                      values[i] = g_variant_new_string (ippGetString (attr, i, NULL));
+                    break;
+
+                  case IPP_TAG_RANGE:
+                    type = G_VARIANT_TYPE_TUPLE;
+
+                    for (i = 0; i < n_attrs; i++)
+                      {
+                        range[0] = g_variant_new_int32 (ippGetRange (attr, i, &(range_uppervalue)));
+                        range[1] = g_variant_new_int32 (range_uppervalue);
+
+                        values[i] = g_variant_new_tuple (range, 2);
+                      }
+                    break;
+
+                  case IPP_TAG_BOOLEAN:
+                    type = G_VARIANT_TYPE_BOOLEAN;
+
+                    for (i = 0; i < n_attrs; i++)
+                      values[i] = g_variant_new_boolean (ippGetBoolean (attr, i));
+                    break;
+
+                  default:
+                    /* do nothing (switch w/ enumeration type) */
+                    break;
+                }
+
+              if (type != NULL)
+                {
+                  g_variant_builder_add (&builder, "{sv}",
+                                         attributes_names[j],
+                                         g_variant_new_array (type, values, n_attrs));
+                }
+
+              g_free (values);
+            }
+        }
+
+      attributes = g_variant_builder_end (&builder);
+    }
+
+  g_task_return_pointer (task, attributes, (GDestroyNotify) g_variant_unref);
+}
+
+void
+pp_job_get_attributes_async (PpJob                *self,
+                             gchar               **attributes_names,
+                             GCancellable         *cancellable,
+                             GAsyncReadyCallback   callback,
+                             gpointer              user_data)
+{
+  g_autoptr(GTask) task = NULL;
+
+  task = g_task_new (self, cancellable, callback, user_data);
+  g_task_set_task_data (task, g_strdupv (attributes_names), (GDestroyNotify) g_strfreev);
+  g_task_run_in_thread (task, _pp_job_get_attributes_thread);
+}
+
+GVariant *
+pp_job_get_attributes_finish (PpJob         *self,
+                              GAsyncResult  *result,
+                              GError       **error)
+{
+  g_return_val_if_fail (g_task_is_valid (result, self), NULL);
+
+  return g_task_propagate_pointer (G_TASK (result), error);
+}
+
+static void
+_pp_job_authenticate_thread (GTask        *task,
+                             gpointer      source_object,
+                             gpointer      task_data,
+                             GCancellable *cancellable)
+{
+  PpJob         *self = source_object;
+  gboolean       result = FALSE;
+  gchar        **auth_info = task_data;
+  ipp_t         *request;
+  ipp_t         *response = NULL;
+  gint           length;
+
+  if (auth_info != NULL)
+    {
+      g_autofree gchar *job_uri = g_strdup_printf ("ipp://localhost/jobs/%d", self->id);
+
+      length = g_strv_length (auth_info);
+
+      request = ippNewRequest (IPP_OP_CUPS_AUTHENTICATE_JOB);
+      ippAddString (request, IPP_TAG_OPERATION, IPP_TAG_URI,
+                    "job-uri", NULL, job_uri);
+      ippAddString (request, IPP_TAG_OPERATION, IPP_TAG_NAME,
+                    "requesting-user-name", NULL, cupsUser ());
+      ippAddStrings (request, IPP_TAG_OPERATION, IPP_TAG_TEXT,
+                     "auth-info", length, NULL, (const char **) auth_info);
+      response = cupsDoRequest (CUPS_HTTP_DEFAULT, request, "/");
+
+      result = response != NULL && ippGetStatusCode (response) <= IPP_OK;
+
+      if (response != NULL)
+        ippDelete (response);
+    }
+
+  g_task_return_boolean (task, result);
+}
+
+void
+pp_job_authenticate_async (PpJob                *self,
+                           gchar               **auth_info,
+                           GCancellable         *cancellable,
+                           GAsyncReadyCallback   callback,
+                           gpointer              user_data)
+{
+  g_autoptr(GTask) task = NULL;
+
+  task = g_task_new (self, cancellable, callback, user_data);
+  g_task_set_task_data (task, g_strdupv (auth_info), (GDestroyNotify) g_strfreev);
+  g_task_run_in_thread (task, _pp_job_authenticate_thread);
+}
+
+gboolean
+pp_job_authenticate_finish (PpJob         *self,
+                            GAsyncResult  *result,
+                            GError       **error)
+{
+  g_return_val_if_fail (g_task_is_valid (result, self), FALSE);
+
+  return g_task_propagate_boolean (G_TASK (result), error);
+}
+
+static void
+pp_job_set_priority_thread (GTask        *task,
+                            gpointer      source_object,
+                            gpointer      task_data,
+                            GCancellable *cancellable)
+{
+  PpJob            *self = source_object;
+  gint              priority = GPOINTER_TO_INT (task_data);
+  ipp_t            *request;
+  gboolean          result = TRUE;
+  g_autofree gchar *uri = NULL;
+
+  request = ippNewRequest (IPP_SET_JOB_ATTRIBUTES);
+  uri = g_strdup_printf ("ipp://localhost/jobs/%d", self->id);
+  ippAddString (request, IPP_TAG_OPERATION, IPP_TAG_URI,
+               "job-uri", NULL, uri);
+  ippAddString (request, IPP_TAG_OPERATION, IPP_TAG_NAME,
+               "requesting-user-name", NULL, cupsUser ());
+
+  ippAddInteger (request, IPP_TAG_JOB, IPP_TAG_INTEGER,
+                "job-priority", priority);
+
+  ippDelete (cupsDoRequest (CUPS_HTTP_DEFAULT, request, "/"));
+
+  if (cupsLastError () > IPP_OK_CONFLICT)
+    {
+      g_warning ("Failed to set job priority: %s", cupsLastErrorString ());
+      result = FALSE;
+    }
+
+  g_task_return_boolean (task, result);
+}
+
+void
+pp_job_set_priority_async (PpJob                *self,
+                           gint                  priority,
+                           GCancellable         *cancellable,
+                           GAsyncReadyCallback   callback,
+                           gpointer              user_data)
+{
+  g_autoptr(GTask) task = NULL;
+
+  task = g_task_new (self, cancellable, callback, user_data);
+  g_task_set_task_data (task, GINT_TO_POINTER (priority), NULL);
+  g_task_run_in_thread (task, pp_job_set_priority_thread);
+}
+
+gboolean
+pp_job_set_priority_finish (PpJob         *self,
+                            GAsyncResult  *result,
+                            GError       **error)
+{
+  g_return_val_if_fail (g_task_is_valid (result, self), FALSE);
+
+  return g_task_propagate_boolean (G_TASK (result), error);
+}
diff --git a/panels/printers/pp-job.h b/panels/printers/pp-job.h
new file mode 100644
index 0000000..b5d7348
--- /dev/null
+++ b/panels/printers/pp-job.h
@@ -0,0 +1,90 @@
+/* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 8 -*-
+ *
+ * Copyright 2015  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 2 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, see <http://www.gnu.org/licenses/>.
+ *
+ * Author: Felipe Borges <feborges@redhat.com>
+ */
+
+#pragma once
+
+#include <gtk/gtk.h>
+#include <glib-object.h>
+
+#include "pp-utils.h"
+
+G_BEGIN_DECLS
+
+G_DECLARE_FINAL_TYPE (PpJob, pp_job, PP, JOB, GObject)
+
+PpJob         *pp_job_new                        (gint                  id,
+                                                  const gchar          *title,
+                                                  gint                  state,
+                                                  gint                  priority,
+                                                  GStrv                 auth_info_required);
+
+const gchar   *pp_job_get_title                  (PpJob                *job);
+
+gint           pp_job_get_state                  (PpJob                *job);
+
+gboolean       pp_job_priority_get_sensitive     (PpJob                *job);
+
+void           pp_job_priority_set_sensitive     (PpJob                *job,
+                                                  gboolean              sensitive);
+
+gint           pp_job_get_priority               (PpJob                *job);
+
+void           pp_job_set_priority               (PpJob                *job,
+                                                  gint                  priority);
+
+GStrv          pp_job_get_auth_info_required     (PpJob                *job);
+
+void           pp_job_set_hold_until_async       (PpJob                *job,
+                                                  const gchar          *job_hold_until);
+
+void           pp_job_cancel_purge_async         (PpJob                *job,
+                                                  gboolean              job_purge);
+
+void           pp_job_get_attributes_async       (PpJob                *job,
+                                                  gchar               **attributes_names,
+                                                  GCancellable         *cancellable,
+                                                  GAsyncReadyCallback   callback,
+                                                  gpointer              user_data);
+
+GVariant      *pp_job_get_attributes_finish      (PpJob                *job,
+                                                  GAsyncResult         *result,
+                                                  GError              **error);
+
+void           pp_job_authenticate_async         (PpJob                *job,
+                                                  gchar               **auth_info,
+                                                  GCancellable         *cancellable,
+                                                  GAsyncReadyCallback   callback,
+                                                  gpointer              user_data);
+
+gboolean       pp_job_authenticate_finish        (PpJob                *job,
+                                                  GAsyncResult         *result,
+                                                  GError              **error);
+
+void           pp_job_set_priority_async         (PpJob                *job,
+                                                  gint                  priority,
+                                                  GCancellable         *cancellable,
+                                                  GAsyncReadyCallback   callback,
+                                                  gpointer              user_data);
+
+gboolean       pp_job_set_priority_finish        (PpJob                *job,
+                                                  GAsyncResult         *result,
+                                                  GError              **error);
+
+G_END_DECLS
diff --git a/panels/printers/pp-jobs-dialog.c b/panels/printers/pp-jobs-dialog.c
new file mode 100644
index 0000000..6a9b704
--- /dev/null
+++ b/panels/printers/pp-jobs-dialog.c
@@ -0,0 +1,539 @@
+/* -*- 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 2 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, see <http://www.gnu.org/licenses/>.
+ *
+ * Author: Marek Kasik <mkasik@redhat.com>
+ */
+
+#include "config.h"
+
+#include <unistd.h>
+#include <stdlib.h>
+
+#include <glib.h>
+#include <glib/gi18n.h>
+#include <glib/gstdio.h>
+#include <gtk/gtk.h>
+#include <gdesktop-enums.h>
+
+#include <cups/cups.h>
+
+#include "pp-jobs-dialog.h"
+#include "pp-utils.h"
+#include "pp-job.h"
+#include "pp-job-row.h"
+#include "pp-cups.h"
+#include "pp-printer.h"
+
+#define EMPTY_TEXT "\xe2\x80\x94"
+
+#define CLOCK_SCHEMA "org.gnome.desktop.interface"
+#define CLOCK_FORMAT_KEY "clock-format"
+
+struct _PpJobsDialog {
+  GtkDialog   parent_instance;
+
+  GtkButton         *authenticate_button;
+  GtkMenuButton     *authenticate_jobs_button;
+  GtkLabel          *authenticate_jobs_label;
+  GtkInfoBar        *authentication_infobar;
+  GtkLabel          *authentication_label;
+  GtkEntry          *domain_entry;
+  GtkLabel          *domain_label;
+  GtkButton         *jobs_clear_all_button;
+  GtkListBox        *jobs_listbox;
+  GtkScrolledWindow *list_jobs_page;
+  GtkBox            *no_jobs_page;
+  GtkEntry          *password_entry;
+  GtkLabel          *password_label;
+  GtkStack          *stack;
+  GListStore        *store;
+  GtkEntry          *username_entry;
+  GtkLabel          *username_label;
+
+  gchar *printer_name;
+
+  gchar    **actual_auth_info_required;
+  gboolean   jobs_filled;
+  gboolean   pop_up_authentication_popup;
+  gint       max_priority;
+
+  GCancellable *get_jobs_cancellable;
+};
+
+G_DEFINE_TYPE (PpJobsDialog, pp_jobs_dialog, GTK_TYPE_DIALOG)
+
+static gboolean
+is_info_required (PpJobsDialog *self,
+                  const gchar  *info)
+{
+  gint i;
+
+  if (self->actual_auth_info_required == NULL)
+    return FALSE;
+
+  for (i = 0; self->actual_auth_info_required[i] != NULL; i++)
+    if (g_strcmp0 (self->actual_auth_info_required[i], info) == 0)
+      return TRUE;
+
+  return FALSE;
+}
+
+static gboolean
+is_domain_required (PpJobsDialog *self)
+{
+  return is_info_required (self, "domain");
+}
+
+static gboolean
+is_username_required (PpJobsDialog *self)
+{
+  return is_info_required (self, "username");
+}
+
+static gboolean
+is_password_required (PpJobsDialog *self)
+{
+  return is_info_required (self, "password");
+}
+
+static gboolean
+auth_popup_filled (PpJobsDialog *self)
+{
+  gboolean domain_required;
+  gboolean username_required;
+  gboolean password_required;
+  guint16  domain_length;
+  guint16  username_length;
+  guint16  password_length;
+
+  domain_required = is_domain_required (self);
+  username_required = is_username_required (self);
+  password_required = is_password_required (self);
+
+  domain_length = gtk_entry_get_text_length (self->domain_entry);
+  username_length = gtk_entry_get_text_length (self->username_entry);
+  password_length = gtk_entry_get_text_length (self->password_entry);
+
+  return (!domain_required || domain_length > 0) &&
+         (!username_required || username_length > 0) &&
+         (!password_required || password_length > 0);
+}
+
+static void
+auth_entries_changed (PpJobsDialog *self)
+{
+  gtk_widget_set_sensitive (GTK_WIDGET (self->authenticate_button), auth_popup_filled (self));
+}
+
+static void
+auth_entries_activated (PpJobsDialog *self)
+{
+  if (auth_popup_filled (self))
+    g_signal_emit_by_name (self->authenticate_button, "activate");
+}
+
+static void
+authenticate_popover_update (PpJobsDialog *self)
+{
+  gboolean   domain_required;
+  gboolean   username_required;
+  gboolean   password_required;
+
+  domain_required = is_domain_required (self);
+  username_required = is_username_required (self);
+  password_required = is_password_required (self);
+
+  gtk_widget_set_visible (GTK_WIDGET (self->domain_label), domain_required);
+  gtk_widget_set_visible (GTK_WIDGET (self->domain_entry), domain_required);
+  if (domain_required)
+    gtk_editable_set_text (GTK_EDITABLE (self->domain_entry), "");
+
+  gtk_widget_set_visible (GTK_WIDGET (self->username_label), username_required);
+  gtk_widget_set_visible (GTK_WIDGET (self->username_entry), username_required);
+  if (username_required)
+    gtk_editable_set_text (GTK_EDITABLE (self->username_entry), cupsUser ());
+
+  gtk_widget_set_visible (GTK_WIDGET (self->password_label), password_required);
+  gtk_widget_set_visible (GTK_WIDGET (self->password_entry), password_required);
+  if (password_required)
+    gtk_editable_set_text (GTK_EDITABLE (self->password_entry), "");
+
+  gtk_widget_set_sensitive (GTK_WIDGET (self->authenticate_button), FALSE);
+}
+
+static void
+pp_job_update_cb (GObject      *source_object,
+                  GAsyncResult *res,
+                  gpointer      user_data)
+{
+  PpJobsDialog     *self = user_data;
+  gboolean          result;
+  g_autoptr(GError) error = NULL;
+  PpJob            *job = PP_JOB (source_object);
+
+  result = pp_job_set_priority_finish (job, res, &error);
+  if (result)
+    {
+      pp_jobs_dialog_update (self);
+    }
+  else if (error != NULL)
+    {
+      if (!g_error_matches (error, G_IO_ERROR, G_IO_ERROR_CANCELLED))
+        {
+          g_warning ("Could not set job priority: %s", error->message);
+        }
+    }
+}
+
+static void
+on_priority_changed (PpJobRow     *job_row,
+                     PpJobsDialog *self)
+{
+  PpJob *job;
+
+  job = pp_job_row_get_job (job_row);
+  pp_job_set_priority_async (job, ++self->max_priority, NULL, pp_job_update_cb, self);
+}
+
+static GtkWidget *
+create_listbox_row (gpointer item,
+                    gpointer user_data)
+{
+  PpJobRow *job_row;
+
+  job_row = pp_job_row_new (PP_JOB (item));
+
+  g_signal_connect (job_row,
+                    "priority-changed",
+                    G_CALLBACK (on_priority_changed),
+                    user_data);
+
+  return GTK_WIDGET (job_row);
+}
+
+static void
+pop_up_authentication_popup (PpJobsDialog *self)
+{
+  if (self->actual_auth_info_required != NULL)
+    gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (self->authenticate_jobs_button), TRUE);
+}
+
+static void
+update_jobs_list_cb (GObject      *source_object,
+                     GAsyncResult *result,
+                     gpointer      user_data)
+{
+  PpJobsDialog        *self = user_data;
+  PpPrinter           *printer = PP_PRINTER (source_object);
+  g_autoptr(GError)    error = NULL;
+  g_autoptr(GPtrArray) jobs;
+  PpJob               *job;
+  gint                 num_of_auth_jobs = 0;
+  gint                 job_priority;
+  guint                state;
+  guint                i;
+  gint                 current_max_value = 1;
+  gint                 first_unprocessed_job = -1;
+
+  g_list_store_remove_all (self->store);
+
+  jobs = pp_printer_get_jobs_finish (printer, result, &error);
+  if (error != NULL)
+    {
+      if (!g_error_matches (error, G_IO_ERROR, G_IO_ERROR_CANCELLED))
+        {
+          g_warning ("Could not get jobs: %s", error->message);
+        }
+
+      return;
+    }
+
+  if (jobs->len > 0)
+    {
+      gtk_widget_set_sensitive (GTK_WIDGET (self->jobs_clear_all_button), TRUE);
+      gtk_stack_set_visible_child (self->stack, GTK_WIDGET (self->list_jobs_page));
+    }
+  else
+    {
+      gtk_widget_set_sensitive (GTK_WIDGET (self->jobs_clear_all_button), FALSE);
+      gtk_stack_set_visible_child (self->stack, GTK_WIDGET (self->no_jobs_page));
+    }
+
+  for (i = 0; i < jobs->len; i++)
+  {
+    job = PP_JOB (g_ptr_array_index (jobs, i));
+    state = pp_job_get_state (job);
+
+    if (state == IPP_JOB_PENDING || state == IPP_JOB_HELD)
+      {
+        if (first_unprocessed_job == -1)
+          {
+            first_unprocessed_job = i;
+            break;
+          }
+      }
+  }
+
+  for (i = 0; i < jobs->len; i++)
+    {
+      job = PP_JOB (g_ptr_array_index (jobs, i));
+      job_priority = pp_job_get_priority (job);
+      pp_job_priority_set_sensitive (job, (pp_job_get_state (job) == IPP_JOB_PENDING ||
+                                     pp_job_get_state (job) == IPP_JOB_HELD) &&
+                                     i > first_unprocessed_job);
+
+      if (job_priority >= current_max_value && job_priority != 100)
+        current_max_value = job_priority;
+
+      g_list_store_append (self->store, g_object_ref (job));
+
+      if (pp_job_get_auth_info_required (job) != NULL)
+        {
+          num_of_auth_jobs++;
+
+          if (self->actual_auth_info_required == NULL)
+            self->actual_auth_info_required = g_strdupv (pp_job_get_auth_info_required (job));
+        }
+    }
+  self->max_priority = current_max_value;
+  if (num_of_auth_jobs > 0)
+    {
+      g_autofree gchar *text = NULL;
+
+      /* Translators: This label shows how many jobs of this printer needs to be authenticated to be printed. */
+      text = g_strdup_printf (ngettext ("%u Job Requires Authentication", "%u Jobs Require Authentication", num_of_auth_jobs), num_of_auth_jobs);
+      gtk_label_set_text (self->authenticate_jobs_label, text);
+
+      gtk_widget_show (GTK_WIDGET (self->authentication_infobar));
+    }
+  else
+    {
+      gtk_widget_hide (GTK_WIDGET (self->authentication_infobar));
+    }
+
+  authenticate_popover_update (self);
+
+  g_clear_object (&self->get_jobs_cancellable);
+
+  if (!self->jobs_filled)
+    {
+      if (self->pop_up_authentication_popup)
+        {
+          pop_up_authentication_popup (self);
+          self->pop_up_authentication_popup = FALSE;
+        }
+
+      self->jobs_filled = TRUE;
+    }
+}
+
+static void
+update_jobs_list (PpJobsDialog *self)
+{
+  g_autoptr(PpPrinter) printer = NULL;
+
+  if (self->printer_name != NULL)
+    {
+      g_cancellable_cancel (self->get_jobs_cancellable);
+      g_clear_object (&self->get_jobs_cancellable);
+
+      self->get_jobs_cancellable = g_cancellable_new ();
+
+      printer = pp_printer_new (self->printer_name);
+      pp_printer_get_jobs_async (printer,
+                                 TRUE,
+                                 CUPS_WHICHJOBS_ACTIVE,
+                                 self->get_jobs_cancellable,
+                                 update_jobs_list_cb,
+                                 self);
+    }
+}
+
+static void
+on_clear_all_button_clicked (PpJobsDialog *self)
+{
+  guint num_items;
+  guint i;
+
+  num_items = g_list_model_get_n_items (G_LIST_MODEL (self->store));
+
+  for (i = 0; i < num_items; i++)
+    {
+      PpJob *job = PP_JOB (g_list_model_get_item (G_LIST_MODEL (self->store), i));
+
+      pp_job_cancel_purge_async (job, FALSE);
+    }
+}
+
+static void
+pp_job_authenticate_cb (GObject      *source_object,
+                        GAsyncResult *res,
+                        gpointer      user_data)
+{
+  PpJobsDialog     *self = user_data;
+  gboolean          result;
+  g_autoptr(GError) error = NULL;
+  PpJob            *job = PP_JOB (source_object);
+
+  result = pp_job_authenticate_finish (job, res, &error);
+  if (result)
+    {
+      pp_jobs_dialog_update (self);
+    }
+  else if (error != NULL)
+    {
+      if (!g_error_matches (error, G_IO_ERROR, G_IO_ERROR_CANCELLED))
+        {
+          g_warning ("Could not authenticate job: %s", error->message);
+        }
+    }
+}
+
+static void
+authenticate_button_clicked (PpJobsDialog *self)
+{
+  PpJob        *job;
+  gchar       **auth_info;
+  guint         num_items;
+  gint          i;
+
+  auth_info = g_new0 (gchar *, g_strv_length (self->actual_auth_info_required) + 1);
+  for (i = 0; self->actual_auth_info_required[i] != NULL; i++)
+    {
+      if (g_strcmp0 (self->actual_auth_info_required[i], "domain") == 0)
+        auth_info[i] = g_strdup (gtk_editable_get_text (GTK_EDITABLE (self->domain_entry)));
+      else if (g_strcmp0 (self->actual_auth_info_required[i], "username") == 0)
+        auth_info[i] = g_strdup (gtk_editable_get_text (GTK_EDITABLE (self->username_entry)));
+      else if (g_strcmp0 (self->actual_auth_info_required[i], "password") == 0)
+        auth_info[i] = g_strdup (gtk_editable_get_text (GTK_EDITABLE (self->password_entry)));
+    }
+
+  num_items = g_list_model_get_n_items (G_LIST_MODEL (self->store));
+  for (i = 0; i < num_items; i++)
+    {
+      job = PP_JOB (g_list_model_get_item (G_LIST_MODEL (self->store), i));
+
+      if (pp_job_get_auth_info_required (job) != NULL)
+        {
+          pp_job_authenticate_async (job, auth_info, NULL, pp_job_authenticate_cb, self);
+        }
+    }
+
+  g_strfreev (auth_info);
+}
+
+PpJobsDialog *
+pp_jobs_dialog_new (const gchar *printer_name)
+{
+  PpJobsDialog *self;
+  g_autofree gchar *text = NULL;
+  g_autofree gchar *title = NULL;
+
+  self = g_object_new (PP_TYPE_JOBS_DIALOG,
+                       "use-header-bar", 1,
+                       NULL);
+
+  self->printer_name = g_strdup (printer_name);
+  self->actual_auth_info_required = NULL;
+  self->jobs_filled = FALSE;
+  self->pop_up_authentication_popup = FALSE;
+
+  /* Translators: This is the printer name for which we are showing the active jobs */
+  title = g_strdup_printf (C_("Printer jobs dialog title", "%s — Active Jobs"), printer_name);
+  gtk_window_set_title (GTK_WINDOW (self), title);
+
+  /* Translators: The printer needs authentication info to print. */
+  text = g_strdup_printf (_("Enter credentials to print from %s."), printer_name);
+  gtk_label_set_text (self->authentication_label, text);
+
+  self->store = g_list_store_new (pp_job_get_type ());
+  gtk_list_box_bind_model (self->jobs_listbox, G_LIST_MODEL (self->store),
+                           create_listbox_row, self, NULL);
+
+  update_jobs_list (self);
+
+  return self;
+}
+
+void
+pp_jobs_dialog_update (PpJobsDialog *self)
+{
+  update_jobs_list (self);
+}
+
+void
+pp_jobs_dialog_authenticate_jobs (PpJobsDialog *self)
+{
+  if (self->jobs_filled)
+    pop_up_authentication_popup (self);
+  else
+    self->pop_up_authentication_popup = TRUE;
+}
+
+static void
+pp_jobs_dialog_init (PpJobsDialog *dialog)
+{
+  gtk_widget_init_template (GTK_WIDGET (dialog));
+}
+
+static void
+pp_jobs_dialog_dispose (GObject *object)
+{
+  PpJobsDialog *self = PP_JOBS_DIALOG (object);
+
+  g_cancellable_cancel (self->get_jobs_cancellable);
+  g_clear_object (&self->get_jobs_cancellable);
+  g_clear_pointer (&self->actual_auth_info_required, g_strfreev);
+  g_clear_pointer (&self->printer_name, g_free);
+
+  G_OBJECT_CLASS (pp_jobs_dialog_parent_class)->dispose (object);
+}
+
+static void
+pp_jobs_dialog_class_init (PpJobsDialogClass *klass)
+{
+  GtkWidgetClass *widget_class = GTK_WIDGET_CLASS (klass);
+  GObjectClass   *object_class = G_OBJECT_CLASS (klass);
+
+  gtk_widget_class_set_template_from_resource (widget_class, "/org/gnome/control-center/printers/pp-jobs-dialog.ui");
+
+  gtk_widget_class_bind_template_child (widget_class, PpJobsDialog, authenticate_button);
+  gtk_widget_class_bind_template_child (widget_class, PpJobsDialog, authenticate_jobs_button);
+  gtk_widget_class_bind_template_child (widget_class, PpJobsDialog, authenticate_jobs_label);
+  gtk_widget_class_bind_template_child (widget_class, PpJobsDialog, authentication_infobar);
+  gtk_widget_class_bind_template_child (widget_class, PpJobsDialog, authentication_label);
+  gtk_widget_class_bind_template_child (widget_class, PpJobsDialog, domain_entry);
+  gtk_widget_class_bind_template_child (widget_class, PpJobsDialog, domain_label);
+  gtk_widget_class_bind_template_child (widget_class, PpJobsDialog, jobs_clear_all_button);
+  gtk_widget_class_bind_template_child (widget_class, PpJobsDialog, jobs_listbox);
+  gtk_widget_class_bind_template_child (widget_class, PpJobsDialog, list_jobs_page);
+  gtk_widget_class_bind_template_child (widget_class, PpJobsDialog, no_jobs_page);
+  gtk_widget_class_bind_template_child (widget_class, PpJobsDialog, password_entry);
+  gtk_widget_class_bind_template_child (widget_class, PpJobsDialog, password_label);
+  gtk_widget_class_bind_template_child (widget_class, PpJobsDialog, stack);
+  gtk_widget_class_bind_template_child (widget_class, PpJobsDialog, username_entry);
+  gtk_widget_class_bind_template_child (widget_class, PpJobsDialog, username_label);
+
+  gtk_widget_class_bind_template_callback (widget_class, authenticate_button_clicked);
+  gtk_widget_class_bind_template_callback (widget_class, on_clear_all_button_clicked);
+  gtk_widget_class_bind_template_callback (widget_class, auth_entries_activated);
+  gtk_widget_class_bind_template_callback (widget_class, auth_entries_changed);
+
+  object_class->dispose = pp_jobs_dialog_dispose;
+
+  gtk_widget_class_add_binding_action (widget_class, GDK_KEY_Escape, 0, "window.close", NULL);
+}
diff --git a/panels/printers/pp-jobs-dialog.h b/panels/printers/pp-jobs-dialog.h
new file mode 100644
index 0000000..c61354b
--- /dev/null
+++ b/panels/printers/pp-jobs-dialog.h
@@ -0,0 +1,35 @@
+/* -*- 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 2 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, see <http://www.gnu.org/licenses/>.
+ *
+ * Author: Marek Kasik <mkasik@redhat.com>
+ */
+
+#pragma once
+
+#include <gtk/gtk.h>
+#include "pp-utils.h"
+
+G_BEGIN_DECLS
+
+#define PP_TYPE_JOBS_DIALOG (pp_jobs_dialog_get_type ())
+G_DECLARE_FINAL_TYPE (PpJobsDialog, pp_jobs_dialog, PP, JOBS_DIALOG, GtkDialog)
+
+PpJobsDialog *pp_jobs_dialog_new               (const gchar  *printer_name);
+void          pp_jobs_dialog_update            (PpJobsDialog *dialog);
+void          pp_jobs_dialog_authenticate_jobs (PpJobsDialog *dialog);
+
+G_END_DECLS
diff --git a/panels/printers/pp-jobs-dialog.ui b/panels/printers/pp-jobs-dialog.ui
new file mode 100644
index 0000000..0a4f0d2
--- /dev/null
+++ b/panels/printers/pp-jobs-dialog.ui
@@ -0,0 +1,234 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!-- Generated with glade 3.20.2 -->
+<interface>
+  <requires lib="gtk+" version="3.22"/>
+  <object class="GtkPopover" id="authentication_popover">
+    <property name="halign">start</property>
+    <property name="valign">start</property>
+    <child>
+      <object class="GtkBox">
+        <property name="margin_start">30</property>
+        <property name="margin_end">30</property>
+        <property name="margin_top">20</property>
+        <property name="margin_bottom">20</property>
+        <property name="orientation">vertical</property>
+        <property name="spacing">20</property>
+        <child>
+          <object class="GtkLabel" id="authentication_label">
+            <property name="margin_top">5</property>
+            <property name="margin_bottom">5</property>
+            <property name="label" translatable="no">Enter credentials to print from %s.</property>
+          </object>
+        </child>
+        <child>
+          <object class="GtkGrid">
+            <property name="row_spacing">10</property>
+            <property name="column_spacing">15</property>
+            <child>
+              <object class="GtkLabel" id="domain_label">
+                <property name="halign">start</property>
+                <property name="label" translatable="yes" comments="Translators: This is a windows domain used with SMB protocol.">Domain</property>
+                <property name="xalign">1</property>
+                <property name="mnemonic_widget">domain_entry</property>
+                <layout>
+                  <property name="column">0</property>
+                  <property name="row">0</property>
+                </layout>
+              </object>
+            </child>
+            <child>
+              <object class="GtkLabel" id="username_label">
+                <property name="halign">start</property>
+                <property name="label" translatable="yes" comments="Translators: This is a username on a print server.">Username</property>
+                <property name="xalign">1</property>
+                <property name="mnemonic_widget">username_entry</property>
+                <layout>
+                  <property name="column">0</property>
+                  <property name="row">1</property>
+                </layout>
+              </object>
+            </child>
+            <child>
+              <object class="GtkLabel" id="password_label">
+                <property name="halign">start</property>
+                <property name="label" translatable="yes" comments="Translators: This is a password needed for printing.">Password</property>
+                <property name="xalign">1</property>
+                <property name="mnemonic_widget">password_entry</property>
+                <layout>
+                  <property name="column">0</property>
+                  <property name="row">2</property>
+                </layout>
+              </object>
+            </child>
+            <child>
+              <object class="GtkEntry" id="domain_entry">
+                <property name="hexpand">True</property>
+                <signal name="changed" handler="auth_entries_changed" swapped="yes"/>
+                <signal name="activate" handler="auth_entries_activated" swapped="yes"/>
+                <layout>
+                  <property name="column">1</property>
+                  <property name="row">0</property>
+                </layout>
+              </object>
+            </child>
+            <child>
+              <object class="GtkEntry" id="username_entry">
+                <property name="hexpand">True</property>
+                <signal name="changed" handler="auth_entries_changed" swapped="yes"/>
+                <signal name="activate" handler="auth_entries_activated" swapped="yes"/>
+                <layout>
+                  <property name="column">1</property>
+                  <property name="row">1</property>
+                </layout>
+              </object>
+            </child>
+            <child>
+              <object class="GtkEntry" id="password_entry">
+                <property name="hexpand">True</property>
+                <property name="visibility">False</property>
+                <property name="invisible_char">*</property>
+                <property name="input_purpose">password</property>
+                <signal name="changed" handler="auth_entries_changed" swapped="yes"/>
+                <signal name="activate" handler="auth_entries_activated" swapped="yes"/>
+                <layout>
+                  <property name="column">1</property>
+                  <property name="row">2</property>
+                </layout>
+              </object>
+            </child>
+          </object>
+        </child>
+        <child>
+          <object class="GtkButton" id="authenticate_button">
+            <property name="label" translatable="yes" comments="Translators: This button authenticates all print jobs and send them for printing.">A_uthenticate</property>
+            <property name="use_underline">True</property>
+            <property name="receives_default">True</property>
+            <property name="halign">end</property>
+            <signal name="clicked" handler="authenticate_button_clicked" swapped="yes"/>
+          </object>
+        </child>
+      </object>
+    </child>
+  </object>
+  <object class="GtkSizeGroup">
+    <widgets>
+      <widget name="domain_label"/>
+      <widget name="username_label"/>
+      <widget name="password_label"/>
+    </widgets>
+  </object>
+  <template class="PpJobsDialog" parent="GtkDialog">
+    <property name="width_request">720</property>
+    <property name="height_request">500</property>
+    <property name="resizable">False</property>
+    <property name="modal">True</property>
+    <property name="destroy_with_parent">True</property>
+    <child internal-child="headerbar">
+      <object class="GtkHeaderBar">
+        <property name="show_title_buttons">True</property>
+        <child>
+          <object class="GtkButton" id="jobs_clear_all_button">
+            <property name="label" translatable="yes" comments="Translators: this action removes (purges) all the listed jobs from the list.">Clear All</property>
+            <property name="receives_default">True</property>
+            <property name="use_underline">True</property>
+            <property name="valign">center</property>
+            <signal name="clicked" handler="on_clear_all_button_clicked" swapped="yes"/>
+            <style>
+              <class name="destructive-action"/>
+            </style>
+          </object>
+        </child>
+      </object>
+    </child>
+    <child>
+      <object class="GtkBox">
+        <property name="orientation">vertical</property>
+        <style>
+          <class name="view"/>
+        </style>
+        <child>
+          <object class="GtkInfoBar" id="authentication_infobar">
+            <child>
+              <object class="GtkBox">
+                <property name="spacing">16</property>
+                <property name="margin-start">12</property>
+                <child>
+                  <object class="GtkLabel" id="authenticate_jobs_label">
+                    <property name="halign">start</property>
+                    <property name="hexpand">False</property>
+                    <property name="wrap">True</property>
+                    <property name="label" translatable="no">2 Jobs Require Authentication</property>
+                    <attributes>
+                      <attribute name="weight" value="bold"/>
+                    </attributes>
+                  </object>
+                </child>
+              </object>
+            </child>
+            <child>
+              <object class="GtkBox">
+                <property name="margin-top">12</property>
+                <property name="margin-bottom">12</property>
+                <property name="margin-start">12</property>
+                <property name="margin-end">2</property>
+                <property name="spacing">6</property>
+                <child>
+                  <object class="GtkMenuButton" id="authenticate_jobs_button">
+                    <property name="label" translatable="yes" comments="Translators: This button pop up authentication dialog for print jobs which need credentials.">_Authenticate</property>
+                    <property name="receives-default">False</property>
+                    <property name="use-underline">True</property>
+                    <property name="halign">end</property>
+                    <property name="valign">GTK_ALIGN_CENTER</property>
+                    <property name="popover">authentication_popover</property>
+                  </object>
+                </child>
+              </object>
+            </child>
+          </object>
+        </child>
+        <child>
+          <object class="GtkStack" id="stack">
+            <child>
+              <object class="GtkScrolledWindow" id="list_jobs_page">
+                <property name="vexpand">True</property>
+                <property name="hscrollbar-policy">never</property>
+                <child>
+                  <object class="GtkListBox" id="jobs_listbox">
+                    <property name="halign">fill</property>
+                    <property name="valign">fill</property>
+                    <property name="selection-mode">none</property>
+                  </object>
+                </child>
+              </object>
+            </child>
+            <child>
+              <object class="GtkBox" id="no_jobs_page">
+                <property name="spacing">10</property>
+                <property name="orientation">vertical</property>
+                <property name="valign">center</property>
+                <child>
+                  <object class="GtkImage">
+                    <property name="valign">start</property>
+                    <property name="pixel_size">64</property>
+                    <property name="icon_name">printer-symbolic</property>
+                    <style>
+                      <class name="dim-label"/>
+                    </style>
+                  </object>
+                </child>
+                <child>
+                  <object class="GtkLabel">
+                    <property name="label" translatable="yes" comments="Translators: this label describes the dialog empty state, with no jobs listed.">No Active Printer Jobs</property>
+                    <style>
+                      <class name="dim-label"/>
+                    </style>
+                  </object>
+                </child>
+              </object>
+            </child>
+          </object>
+        </child>
+      </object>
+    </child>
+  </template>
+</interface>
diff --git a/panels/printers/pp-maintenance-command.c b/panels/printers/pp-maintenance-command.c
new file mode 100644
index 0000000..fd843d0
--- /dev/null
+++ b/panels/printers/pp-maintenance-command.c
@@ -0,0 +1,390 @@
+/* -*- 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 2 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, see <http://www.gnu.org/licenses/>.
+ *
+ * Author: Marek Kasik <mkasik@redhat.com>
+ */
+
+#include <glib/gstdio.h>
+
+#include "pp-maintenance-command.h"
+
+#include "pp-utils.h"
+
+#if (CUPS_VERSION_MAJOR > 1) || (CUPS_VERSION_MINOR > 5)
+#define HAVE_CUPS_1_6 1
+#endif
+
+#ifndef HAVE_CUPS_1_6
+#define ippGetCount(attr)     attr->num_values
+#define ippGetValueTag(attr)  attr->value_tag
+#define ippGetStatusCode(ipp) ipp->request.status.status_code
+#define ippGetString(attr, element, language) attr->values[element].string.text
+#endif
+
+struct _PpMaintenanceCommand
+{
+  GObject parent_instance;
+
+  gchar *printer_name;
+  gchar *command;
+  gchar *parameters;
+  gchar *title;
+};
+
+G_DEFINE_TYPE (PpMaintenanceCommand, pp_maintenance_command, G_TYPE_OBJECT);
+
+enum {
+  PROP_0 = 0,
+  PROP_PRINTER_NAME,
+  PROP_COMMAND,
+  PROP_PARAMETERS,
+  PROP_TITLE
+};
+
+static void
+pp_maintenance_command_finalize (GObject *object)
+{
+  PpMaintenanceCommand *self = PP_MAINTENANCE_COMMAND (object);
+
+  g_clear_pointer (&self->printer_name, g_free);
+  g_clear_pointer (&self->command, g_free);
+  g_clear_pointer (&self->parameters, g_free);
+  g_clear_pointer (&self->title, g_free);
+
+  G_OBJECT_CLASS (pp_maintenance_command_parent_class)->finalize (object);
+}
+
+static void
+pp_maintenance_command_get_property (GObject    *object,
+                                     guint       prop_id,
+                                     GValue     *value,
+                                     GParamSpec *param_spec)
+{
+  PpMaintenanceCommand *self = PP_MAINTENANCE_COMMAND (object);
+
+  switch (prop_id)
+    {
+      case PROP_PRINTER_NAME:
+        g_value_set_string (value, self->printer_name);
+        break;
+      case PROP_COMMAND:
+        g_value_set_string (value, self->command);
+        break;
+      case PROP_PARAMETERS:
+        g_value_set_string (value, self->parameters);
+        break;
+      case PROP_TITLE:
+        g_value_set_string (value, self->title);
+        break;
+      default:
+        G_OBJECT_WARN_INVALID_PROPERTY_ID (object,
+                                           prop_id,
+                                           param_spec);
+      break;
+    }
+}
+
+static void
+pp_maintenance_command_set_property (GObject      *object,
+                                     guint         prop_id,
+                                     const GValue *value,
+                                     GParamSpec   *param_spec)
+{
+  PpMaintenanceCommand *self = PP_MAINTENANCE_COMMAND (object);
+
+  switch (prop_id)
+    {
+      case PROP_PRINTER_NAME:
+        g_free (self->printer_name);
+        self->printer_name = g_value_dup_string (value);
+        break;
+      case PROP_COMMAND:
+        g_free (self->command);
+        self->command = g_value_dup_string (value);
+        break;
+      case PROP_PARAMETERS:
+        g_free (self->parameters);
+        self->parameters = g_value_dup_string (value);
+        break;
+      case PROP_TITLE:
+        g_free (self->title);
+        self->title = g_value_dup_string (value);
+        break;
+      default:
+        G_OBJECT_WARN_INVALID_PROPERTY_ID (object,
+                                           prop_id,
+                                           param_spec);
+        break;
+    }
+}
+
+static void
+pp_maintenance_command_class_init (PpMaintenanceCommandClass *klass)
+{
+  GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
+
+  gobject_class->set_property = pp_maintenance_command_set_property;
+  gobject_class->get_property = pp_maintenance_command_get_property;
+  gobject_class->finalize = pp_maintenance_command_finalize;
+
+  g_object_class_install_property (gobject_class, PROP_PRINTER_NAME,
+    g_param_spec_string ("printer-name",
+                         "Printer name",
+                         "Name of the printer",
+                         NULL,
+                         G_PARAM_READWRITE));
+
+  g_object_class_install_property (gobject_class, PROP_COMMAND,
+    g_param_spec_string ("command",
+                         "Maintenance command",
+                         "Command to execute",
+                         NULL,
+                         G_PARAM_READWRITE));
+
+  g_object_class_install_property (gobject_class, PROP_PARAMETERS,
+    g_param_spec_string ("parameters",
+                         "Optional parameters",
+                         "Optional parameters for the maintenance command",
+                         NULL,
+                         G_PARAM_READWRITE));
+
+  g_object_class_install_property (gobject_class, PROP_TITLE,
+    g_param_spec_string ("title",
+                         "Command title",
+                         "Title of the job by which the command will be executed",
+                         NULL,
+                         G_PARAM_READWRITE));
+}
+
+static void
+pp_maintenance_command_init (PpMaintenanceCommand *self)
+{
+}
+
+PpMaintenanceCommand *
+pp_maintenance_command_new (const gchar *printer_name,
+                            const gchar *command,
+                            const gchar *parameters,
+                            const gchar *title)
+{
+  return g_object_new (PP_TYPE_MAINTENANCE_COMMAND,
+                       "printer-name", printer_name,
+                       "command", command,
+                       "parameters", parameters,
+                       "title", title,
+                       NULL);
+}
+
+static gboolean _pp_maintenance_command_is_supported (const gchar *printer_name,
+                                                      const gchar *command);
+
+static void
+_pp_maintenance_command_execute_thread (GTask        *task,
+                                        gpointer      source_object,
+                                        gpointer      task_data,
+                                        GCancellable *cancellable)
+{
+  PpMaintenanceCommand        *self = PP_MAINTENANCE_COMMAND (source_object);
+  gboolean                     success = FALSE;
+  GError                      *error = NULL;
+
+  if (_pp_maintenance_command_is_supported (self->printer_name, self->command))
+    {
+      ipp_t            *request;
+      ipp_t            *response = NULL;
+      g_autofree gchar *printer_uri = NULL;
+      g_autofree gchar *file_name = NULL;
+      int               fd = -1;
+
+      printer_uri = g_strdup_printf ("ipp://localhost/printers/%s",
+                                     self->printer_name);
+
+      request = ippNewRequest (IPP_PRINT_JOB);
+
+      ippAddString (request, IPP_TAG_OPERATION, IPP_TAG_URI,
+                    "printer-uri", NULL, printer_uri);
+      ippAddString (request, IPP_TAG_OPERATION, IPP_TAG_NAME,
+                    "job-name", NULL, self->title);
+      ippAddString (request, IPP_TAG_JOB, IPP_TAG_MIMETYPE,
+                    "document-format", NULL, "application/vnd.cups-command");
+
+      fd = g_file_open_tmp ("ccXXXXXX", &file_name, &error);
+
+      if (fd != -1)
+        {
+          FILE *file;
+
+          file = fdopen (fd, "w");
+          fprintf (file, "#CUPS-COMMAND\n");
+          fprintf (file, "%s", self->command);
+          if (self->parameters)
+            fprintf (file, " %s", self->parameters);
+          fprintf (file, "\n");
+          fclose (file);
+
+          response = cupsDoFileRequest (CUPS_HTTP_DEFAULT, request, "/", file_name);
+          g_unlink (file_name);
+
+          if (response != NULL)
+            {
+              if (ippGetStatusCode (response) <= IPP_OK_CONFLICT)
+                {
+                  success = TRUE;
+                }
+
+              ippDelete (response);
+            }
+        }
+    }
+  else
+    {
+      success = TRUE;
+    }
+
+  if (!success)
+    {
+      g_task_return_new_error (task,
+                               G_IO_ERROR,
+                               G_IO_ERROR_FAILED,
+                               "Execution of maintenance command failed.");
+    }
+
+  g_task_return_boolean (task, success);
+}
+
+void
+pp_maintenance_command_execute_async (PpMaintenanceCommand *self,
+                                      GCancellable         *cancellable,
+                                      GAsyncReadyCallback   callback,
+                                      gpointer              user_data)
+{
+  g_autoptr(GTask) task = NULL;
+
+  task = g_task_new (self, cancellable, callback, user_data);
+  g_task_set_check_cancellable (task, TRUE);
+  g_task_run_in_thread (task, _pp_maintenance_command_execute_thread);
+}
+
+gboolean
+pp_maintenance_command_execute_finish (PpMaintenanceCommand  *self,
+                                       GAsyncResult          *result,
+                                       GError               **error)
+{
+  g_return_val_if_fail (g_task_is_valid (result, self), FALSE);
+
+  return g_task_propagate_boolean (G_TASK (result), error);
+}
+
+static gboolean
+_pp_maintenance_command_is_supported (const gchar *printer_name,
+                                      const gchar *command)
+{
+  ipp_attribute_t   *attr = NULL;
+  gboolean           is_supported = FALSE;
+  ipp_t             *request;
+  ipp_t             *response = NULL;
+  g_autofree gchar  *printer_uri = NULL;
+  GPtrArray         *available_commands = NULL;
+  int                i;
+
+  printer_uri = g_strdup_printf ("ipp://localhost/printers/%s",
+                                 printer_name);
+
+  request = ippNewRequest (IPP_GET_PRINTER_ATTRIBUTES);
+  ippAddString (request, IPP_TAG_OPERATION, IPP_TAG_URI,
+                "printer-uri", NULL, printer_uri);
+  ippAddString (request, IPP_TAG_OPERATION, IPP_TAG_KEYWORD,
+                "requested-attributes", NULL, "printer-commands");
+  response = cupsDoRequest (CUPS_HTTP_DEFAULT, request, "/");
+  if (response != NULL)
+    {
+      if (ippGetStatusCode (response) <= IPP_OK_CONFLICT)
+        {
+          int commands_count;
+
+          attr = ippFindAttribute (response, "printer-commands", IPP_TAG_ZERO);
+          commands_count = attr != NULL ? ippGetCount (attr) : 0;
+          if (commands_count > 0 &&
+              ippGetValueTag (attr) != IPP_TAG_NOVALUE &&
+              (ippGetValueTag (attr) == IPP_TAG_KEYWORD))
+            {
+              available_commands = g_ptr_array_new_full (commands_count, g_free);
+              for (i = 0; i < commands_count; ++i)
+                {
+                  /* Array gains ownership of the lower-cased string */
+                  g_ptr_array_add (available_commands, g_ascii_strdown (ippGetString (attr, i, NULL), -1));
+                }
+            }
+        }
+
+      ippDelete (response);
+    }
+
+  if (available_commands != NULL)
+    {
+      g_autofree gchar *command_lowercase = g_ascii_strdown (command, -1);
+      for (i = 0; i < available_commands->len; ++i)
+        {
+          const gchar *available_command = g_ptr_array_index (available_commands, i);
+          if (g_strcmp0 (available_command, command_lowercase) == 0)
+            {
+              is_supported = TRUE;
+              break;
+            }
+        }
+
+      g_ptr_array_free (available_commands, TRUE);
+    }
+
+  return is_supported;
+}
+
+static void
+_pp_maintenance_command_is_supported_thread (GTask        *task,
+                                             gpointer      source_object,
+                                             gpointer      task_data,
+                                             GCancellable *cancellable)
+{
+  PpMaintenanceCommand        *self = PP_MAINTENANCE_COMMAND (source_object);
+  gboolean                     success = FALSE;
+
+  success = _pp_maintenance_command_is_supported (self->printer_name, self->command);
+  g_task_return_boolean (task, success);
+}
+
+void
+pp_maintenance_command_is_supported_async  (PpMaintenanceCommand *self,
+                                            GCancellable         *cancellable,
+                                            GAsyncReadyCallback   callback,
+                                            gpointer              user_data)
+{
+  g_autoptr(GTask) task = NULL;
+
+  task = g_task_new (self, cancellable, callback, user_data);
+  g_task_set_check_cancellable (task, TRUE);
+  g_task_run_in_thread (task, _pp_maintenance_command_is_supported_thread);
+}
+
+gboolean
+pp_maintenance_command_is_supported_finish (PpMaintenanceCommand  *self,
+                                            GAsyncResult          *result,
+                                            GError               **error)
+{
+  g_return_val_if_fail (g_task_is_valid (result, self), FALSE);
+
+  return g_task_propagate_boolean (G_TASK (result), error);
+}
diff --git a/panels/printers/pp-maintenance-command.h b/panels/printers/pp-maintenance-command.h
new file mode 100644
index 0000000..b5bacfe
--- /dev/null
+++ b/panels/printers/pp-maintenance-command.h
@@ -0,0 +1,52 @@
+/* -*- 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 2 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, see <http://www.gnu.org/licenses/>.
+ *
+ * Author: Marek Kasik <mkasik@redhat.com>
+ */
+
+#pragma once
+
+#include <glib-object.h>
+#include <gio/gio.h>
+
+G_BEGIN_DECLS
+
+#define PP_TYPE_MAINTENANCE_COMMAND (pp_maintenance_command_get_type ())
+G_DECLARE_FINAL_TYPE (PpMaintenanceCommand, pp_maintenance_command, PP, MAINTENANCE_COMMAND, GObject)
+
+PpMaintenanceCommand *pp_maintenance_command_new                 (const gchar *printer_name,
+                                                                  const gchar *command,
+                                                                  const gchar *parameters,
+                                                                  const gchar *title);
+
+void                  pp_maintenance_command_execute_async       (PpMaintenanceCommand *command,
+                                                                  GCancellable         *cancellable,
+                                                                  GAsyncReadyCallback   callback,
+                                                                  gpointer              user_data);
+
+gboolean              pp_maintenance_command_execute_finish      (PpMaintenanceCommand  *command,
+                                                                  GAsyncResult          *result,
+                                                                  GError               **error);
+void                  pp_maintenance_command_is_supported_async  (PpMaintenanceCommand *command,
+                                                                  GCancellable         *cancellable,
+                                                                  GAsyncReadyCallback   callback,
+                                                                  gpointer              user_data);
+
+gboolean              pp_maintenance_command_is_supported_finish (PpMaintenanceCommand  *command,
+                                                                  GAsyncResult          *result,
+                                                                  GError               **error);
+G_END_DECLS
diff --git a/panels/printers/pp-new-printer-dialog.c b/panels/printers/pp-new-printer-dialog.c
new file mode 100644
index 0000000..a3c0e48
--- /dev/null
+++ b/panels/printers/pp-new-printer-dialog.c
@@ -0,0 +1,1929 @@
+/* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 8 -*-
+ *
+ * Copyright 2009-2010  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 2 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, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#include "config.h"
+
+#include <unistd.h>
+#include <stdlib.h>
+
+#include <adwaita.h>
+#include <glib.h>
+#include <glib/gi18n.h>
+#include <glib/gstdio.h>
+#include <gdk/x11/gdkx.h>
+#include <gtk/gtk.h>
+
+#include "pp-new-printer-dialog.h"
+#include "pp-cups.h"
+#include "pp-host.h"
+#include "pp-new-printer.h"
+#include "pp-ppd-selection-dialog.h"
+#include "pp-samba.h"
+#include "pp-utils.h"
+
+#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
+
+/*
+ * Additional delay to the default 150ms delay in GtkSearchEntry
+ * resulting in total delay of 500ms.
+ */
+#define HOST_SEARCH_DELAY (500 - 150)
+
+#define AUTHENTICATION_PAGE "authentication-page"
+#define ADDPRINTER_PAGE "addprinter-page"
+
+static void     set_device (PpNewPrinterDialog *self,
+                            PpPrintDevice      *device,
+                            GtkTreeIter        *iter);
+static void     replace_device (PpNewPrinterDialog *self,
+                                PpPrintDevice      *old_device,
+                                PpPrintDevice      *new_device);
+static void     populate_devices_list (PpNewPrinterDialog *self);
+static void     search_entry_activated_cb (PpNewPrinterDialog *self);
+static void     search_entry_changed_cb (PpNewPrinterDialog *self);
+static void     new_printer_dialog_response_cb (PpNewPrinterDialog *self,
+                                                gint                response_id);
+static void     update_dialog_state (PpNewPrinterDialog *self);
+static void     add_devices_to_list (PpNewPrinterDialog  *self,
+                                     GPtrArray           *devices);
+static void     remove_device_from_list (PpNewPrinterDialog *self,
+                                         const gchar        *device_name);
+
+enum
+{
+  DEVICE_GICON_COLUMN = 0,
+  DEVICE_NAME_COLUMN,
+  DEVICE_DISPLAY_NAME_COLUMN,
+  DEVICE_DESCRIPTION_COLUMN,
+  SERVER_NEEDS_AUTHENTICATION_COLUMN,
+  DEVICE_VISIBLE_COLUMN,
+  DEVICE_COLUMN,
+  DEVICE_N_COLUMNS
+};
+
+struct _PpNewPrinterDialog
+{
+  GtkDialog parent_instance;
+
+  GPtrArray *local_cups_devices;
+
+  GtkListStore       *devices_liststore;
+  GtkTreeModelFilter *devices_model_filter;
+
+  /* headerbar */
+  GtkHeaderBar         *headerbar;
+  AdwWindowTitle       *header_title;
+
+  /* headerbar topleft buttons */
+  GtkStack           *headerbar_topleft_buttons;
+  GtkButton          *go_back_button;
+
+  /* headerbar topright buttons */
+  GtkStack           *headerbar_topright_buttons;
+  GtkButton          *new_printer_add_button;
+  GtkButton          *unlock_button;
+  GtkButton          *authenticate_button;
+  /* end headerbar */
+
+  /* dialogstack */
+  GtkStack           *dialog_stack;
+  GtkStack           *stack;
+
+  /* scrolledwindow1 */
+  GtkScrolledWindow  *scrolledwindow1;
+  GtkTreeView        *devices_treeview;
+
+  GtkEntry           *search_entry;
+
+  /* authentication page */
+  GtkLabel           *authentication_title;
+  GtkLabel           *authentication_text;
+  GtkEntry           *username_entry;
+  GtkEntry           *password_entry;
+  /* end dialog stack */
+
+  UserResponseCallback user_callback;
+  gpointer             user_data;
+
+  cups_dest_t *dests;
+  gint         num_of_dests;
+
+  GCancellable *cancellable;
+  GCancellable *remote_host_cancellable;
+
+  gboolean  cups_searching;
+  gboolean  samba_authenticated_searching;
+  gboolean  samba_searching;
+
+  PpPPDSelectionDialog *ppd_selection_dialog;
+
+  PpPrintDevice *new_device;
+
+  PPDList *list;
+
+  GIcon *local_printer_icon;
+  GIcon *remote_printer_icon;
+  GIcon *authenticated_server_icon;
+
+  PpHost  *snmp_host;
+  PpHost  *socket_host;
+  PpHost  *lpd_host;
+  PpHost  *remote_cups_host;
+  PpSamba *samba_host;
+  guint    host_search_timeout_id;
+};
+
+G_DEFINE_TYPE (PpNewPrinterDialog, pp_new_printer_dialog, GTK_TYPE_DIALOG)
+
+typedef struct
+{
+  gchar    *server_name;
+  gpointer  dialog;
+} AuthSMBData;
+
+static void
+get_authenticated_samba_devices_cb (GObject      *source_object,
+                                    GAsyncResult *res,
+                                    gpointer      user_data)
+{
+  AuthSMBData               *data = user_data;
+  PpNewPrinterDialog        *self = PP_NEW_PRINTER_DIALOG (data->dialog);
+  g_autoptr(GPtrArray)       devices = NULL;
+  gboolean                   cancelled = FALSE;
+  g_autoptr(GError)          error = NULL;
+
+  devices = pp_samba_get_devices_finish (PP_SAMBA (source_object), res, &error);
+
+  if (devices != NULL)
+    {
+      self->samba_authenticated_searching = FALSE;
+
+      for (guint i = 0; i < devices->len; i++)
+        {
+          PpPrintDevice *device = g_ptr_array_index (devices, i);
+
+          if (pp_print_device_is_authenticated_server (device))
+            {
+              cancelled = TRUE;
+              break;
+            }
+        }
+
+      if (!cancelled)
+        {
+          if (devices != NULL)
+            {
+              add_devices_to_list (self, devices);
+
+              if (devices->len > 0)
+                {
+                  gtk_editable_set_text (GTK_EDITABLE (self->search_entry),
+                                         pp_print_device_get_device_location (g_ptr_array_index (devices, 0)));
+                  search_entry_activated_cb (self);
+                }
+            }
+        }
+
+      update_dialog_state (self);
+    }
+  else
+    {
+      if (!g_error_matches (error, G_IO_ERROR, G_IO_ERROR_CANCELLED))
+        {
+          g_warning ("%s", error->message);
+
+          self->samba_authenticated_searching = FALSE;
+          update_dialog_state (self);
+        }
+    }
+
+  g_free (data->server_name);
+  g_free (data);
+}
+
+static void
+go_to_page (PpNewPrinterDialog *self,
+            const gchar        *page)
+{
+  gtk_stack_set_visible_child_name (self->dialog_stack, page);
+  gtk_stack_set_visible_child_name (self->headerbar_topright_buttons, page);
+  gtk_stack_set_visible_child_name (self->headerbar_topleft_buttons, page);
+}
+
+static void
+on_authenticate (PpNewPrinterDialog *self)
+{
+  gchar                     *hostname = NULL;
+  gchar                     *username = NULL;
+  gchar                     *password = NULL;
+
+  username = g_strdup (gtk_editable_get_text (GTK_EDITABLE (self->username_entry)));
+  password = g_strdup (gtk_editable_get_text (GTK_EDITABLE (self->password_entry)));
+
+  if ((username == NULL) || (username[0] == '\0') ||
+      (password == NULL) || (password[0] == '\0'))
+    {
+      g_clear_pointer (&username, g_free);
+      g_clear_pointer (&password, g_free);
+      return;
+    }
+
+  pp_samba_set_auth_info (PP_SAMBA (self->samba_host), username, password);
+
+  adw_window_title_set_title (self->header_title, _("Add Printer"));
+  go_to_page (self, ADDPRINTER_PAGE);
+
+  g_object_get (PP_HOST (self->samba_host), "hostname", &hostname, NULL);
+  remove_device_from_list (self, hostname);
+}
+
+static void
+on_authentication_required (PpNewPrinterDialog *self)
+{
+  g_autofree gchar          *hostname = NULL;
+  g_autofree gchar          *title = NULL;
+  g_autofree gchar          *text = NULL;
+
+  adw_window_title_set_subtitle (self->header_title, NULL);
+  adw_window_title_set_title (self->header_title, _("Unlock Print Server"));
+
+  g_object_get (self->samba_host, "hostname", &hostname, NULL);
+  /* Translators: Samba server needs authentication of the user to show list of its printers. */
+  title = g_strdup_printf (_("Unlock %s."), hostname);
+  gtk_label_set_text (self->authentication_title, title);
+
+  /* Translators: Samba server needs authentication of the user to show list of its printers. */
+  text = g_strdup_printf (_("Enter username and password to view printers on %s."), hostname);
+  gtk_label_set_text (self->authentication_text, text);
+
+  go_to_page (self, AUTHENTICATION_PAGE);
+
+  g_signal_connect_object (self->authenticate_button, "clicked", G_CALLBACK (on_authenticate), self, G_CONNECT_SWAPPED);
+}
+
+static void
+auth_entries_changed (PpNewPrinterDialog *self)
+{
+  gboolean                   can_authenticate = FALSE;
+  gchar                     *username = NULL;
+  gchar                     *password = NULL;
+
+  username = g_strdup (gtk_editable_get_text (GTK_EDITABLE (self->username_entry)));
+  password = g_strdup (gtk_editable_get_text (GTK_EDITABLE (self->password_entry)));
+
+  can_authenticate = (username != NULL && username[0] != '\0' &&
+                      password != NULL && password[0] != '\0');
+
+  gtk_widget_set_sensitive (GTK_WIDGET (self->authenticate_button), can_authenticate);
+
+  g_clear_pointer (&username, g_free);
+  g_clear_pointer (&password, g_free);
+}
+
+static void
+on_go_back_button_clicked (PpNewPrinterDialog *self)
+{
+  pp_samba_set_auth_info (self->samba_host, NULL, NULL);
+  g_clear_object (&self->samba_host);
+
+  go_to_page (self, ADDPRINTER_PAGE);
+  adw_window_title_set_title (self->header_title, _("Add Printer"));
+  gtk_widget_set_sensitive (GTK_WIDGET (self->new_printer_add_button), FALSE);
+
+  gtk_tree_selection_unselect_all (gtk_tree_view_get_selection (self->devices_treeview));
+}
+
+static void
+authenticate_samba_server (PpNewPrinterDialog *self)
+{
+  GtkTreeModel              *model;
+  GtkTreeIter                iter;
+  AuthSMBData               *data;
+  gchar                     *server_name = NULL;
+
+  gtk_widget_set_sensitive (GTK_WIDGET (self->unlock_button), FALSE);
+  gtk_widget_set_sensitive (GTK_WIDGET (self->authenticate_button), FALSE);
+  gtk_widget_grab_focus (GTK_WIDGET (self->username_entry));
+
+  if (gtk_tree_selection_get_selected (gtk_tree_view_get_selection (self->devices_treeview), &model, &iter))
+    {
+      gtk_tree_model_get (model, &iter,
+                          DEVICE_NAME_COLUMN, &server_name,
+                          -1);
+
+      if (server_name != NULL)
+        {
+          g_clear_object (&self->samba_host);
+
+          self->samba_host = pp_samba_new (server_name);
+          g_signal_connect_object (self->samba_host,
+                                   "authentication-required",
+                                   G_CALLBACK (on_authentication_required),
+                                   self, G_CONNECT_SWAPPED);
+
+          self->samba_authenticated_searching = TRUE;
+          update_dialog_state (self);
+
+          data = g_new (AuthSMBData, 1);
+          data->server_name = server_name;
+          data->dialog = self;
+
+          pp_samba_get_devices_async (self->samba_host,
+                                      TRUE,
+                                      self->cancellable,
+                                      get_authenticated_samba_devices_cb,
+                                      data);
+        }
+    }
+}
+
+static void
+device_selection_changed_cb (PpNewPrinterDialog *self)
+{
+  GtkTreeModel              *model;
+  GtkTreeIter                iter;
+  gboolean                   authentication_needed;
+  gboolean                   selected;
+
+  selected = gtk_tree_selection_get_selected (gtk_tree_view_get_selection (self->devices_treeview),
+                                              &model,
+                                              &iter);
+
+  if (selected)
+    {
+      gtk_tree_model_get (model, &iter,
+                          SERVER_NEEDS_AUTHENTICATION_COLUMN, &authentication_needed,
+                          -1);
+
+      gtk_widget_set_sensitive (GTK_WIDGET (self->new_printer_add_button), selected);
+      gtk_widget_set_sensitive (GTK_WIDGET (self->unlock_button), authentication_needed);
+
+      if (authentication_needed)
+        gtk_stack_set_visible_child_name (self->headerbar_topright_buttons, "unlock_button");
+      else
+        gtk_stack_set_visible_child_name (self->headerbar_topright_buttons, ADDPRINTER_PAGE);
+    }
+}
+
+static void
+remove_device_from_list (PpNewPrinterDialog *self,
+                         const gchar        *device_name)
+{
+  GtkTreeIter                iter;
+  gboolean                   cont;
+
+  cont = gtk_tree_model_get_iter_first (GTK_TREE_MODEL (self->devices_liststore), &iter);
+  while (cont)
+    {
+      g_autoptr(PpPrintDevice) device = NULL;
+
+      gtk_tree_model_get (GTK_TREE_MODEL (self->devices_liststore), &iter,
+                          DEVICE_COLUMN, &device,
+                          -1);
+
+      if (g_strcmp0 (pp_print_device_get_device_name (device), device_name) == 0)
+        {
+          gtk_list_store_remove (self->devices_liststore, &iter);
+          break;
+        }
+
+      cont = gtk_tree_model_iter_next (GTK_TREE_MODEL (self->devices_liststore), &iter);
+    }
+
+  update_dialog_state (self);
+}
+
+static gboolean
+prepend_original_name (GtkTreeModel *model,
+                       GtkTreePath  *path,
+                       GtkTreeIter  *iter,
+                       gpointer      data)
+{
+  g_autoptr(PpPrintDevice) device = NULL;
+  GList         **list = data;
+
+  gtk_tree_model_get (model, iter,
+                      DEVICE_COLUMN, &device,
+                      -1);
+
+  *list = g_list_prepend (*list, g_strdup (pp_print_device_get_device_original_name (device)));
+
+  return FALSE;
+}
+
+static void
+add_device_to_list (PpNewPrinterDialog *self,
+                    PpPrintDevice      *device)
+{
+  GList                     *original_names_list = NULL;
+  gint                       acquisition_method;
+
+  if (device)
+    {
+      if (pp_print_device_get_host_name (device) == NULL)
+        {
+          g_autofree gchar *host_name = guess_device_hostname (device);
+          g_object_set (device, "host-name", host_name, NULL);
+        }
+
+      acquisition_method = pp_print_device_get_acquisition_method (device);
+      if (pp_print_device_get_device_id (device) ||
+          pp_print_device_get_device_ppd (device) ||
+          (pp_print_device_get_host_name (device) &&
+           acquisition_method == ACQUISITION_METHOD_REMOTE_CUPS_SERVER) ||
+           acquisition_method == ACQUISITION_METHOD_SAMBA_HOST ||
+           acquisition_method == ACQUISITION_METHOD_SAMBA ||
+          (pp_print_device_get_device_uri (device) &&
+           (acquisition_method == ACQUISITION_METHOD_JETDIRECT ||
+            acquisition_method == ACQUISITION_METHOD_LPD)))
+        {
+          g_autofree gchar *canonicalized_name = NULL;
+
+          g_object_set (device,
+                        "device-original-name", pp_print_device_get_device_name (device),
+                        NULL);
+
+          gtk_tree_model_foreach (GTK_TREE_MODEL (self->devices_liststore),
+                                  prepend_original_name,
+                                  &original_names_list);
+
+          original_names_list = g_list_reverse (original_names_list);
+
+          canonicalized_name = canonicalize_device_name (original_names_list,
+                                                         self->local_cups_devices,
+                                                         self->dests,
+                                                         self->num_of_dests,
+                                                         device);
+
+          g_list_free_full (original_names_list, g_free);
+
+          g_object_set (device,
+                        "display-name", canonicalized_name,
+                        "device-name", canonicalized_name,
+                        NULL);
+
+          if (pp_print_device_get_acquisition_method (device) == ACQUISITION_METHOD_DEFAULT_CUPS_SERVER)
+            g_ptr_array_add (self->local_cups_devices, g_object_ref (device));
+          else
+            set_device (self, device, NULL);
+        }
+      else if (pp_print_device_is_authenticated_server (device) &&
+               pp_print_device_get_host_name (device) != NULL)
+        {
+          g_autoptr(PpPrintDevice) store_device = NULL;
+
+          store_device = g_object_new (PP_TYPE_PRINT_DEVICE,
+                                       "device-name", pp_print_device_get_host_name (device),
+                                       "host-name", pp_print_device_get_host_name (device),
+                                       "is-authenticated-server", pp_print_device_is_authenticated_server (device),
+                                       NULL);
+
+          set_device (self, store_device, NULL);
+        }
+    }
+}
+
+static void
+add_devices_to_list (PpNewPrinterDialog  *self,
+                     GPtrArray           *devices)
+{
+  for (guint i = 0; i < devices->len; i++)
+    add_device_to_list (self, g_ptr_array_index (devices, i));
+}
+
+static PpPrintDevice *
+device_in_list (gchar *device_uri,
+                GPtrArray *device_list)
+{
+  for (guint i = 0; i < device_list->len; i++)
+    {
+      PpPrintDevice *device = g_ptr_array_index (device_list, i);
+      /* GroupPhysicalDevices returns uris without port numbers */
+      if (pp_print_device_get_device_uri (device) != NULL &&
+          g_str_has_prefix (pp_print_device_get_device_uri (device), device_uri))
+        return g_object_ref (device);
+    }
+
+  return NULL;
+}
+
+static PpPrintDevice *
+device_in_liststore (gchar        *device_uri,
+                     GtkListStore *device_liststore)
+{
+  GtkTreeIter    iter;
+  gboolean       cont;
+
+  cont = gtk_tree_model_get_iter_first (GTK_TREE_MODEL (device_liststore), &iter);
+  while (cont)
+    {
+      g_autoptr(PpPrintDevice) device = NULL;
+
+      gtk_tree_model_get (GTK_TREE_MODEL (device_liststore), &iter,
+                          DEVICE_COLUMN, &device,
+                          -1);
+
+      /* GroupPhysicalDevices returns uris without port numbers */
+      if (pp_print_device_get_device_uri (device) != NULL &&
+          g_str_has_prefix (pp_print_device_get_device_uri (device), device_uri))
+        {
+          return g_steal_pointer(&device);
+        }
+
+      cont = gtk_tree_model_iter_next (GTK_TREE_MODEL (device_liststore), &iter);
+    }
+
+  return NULL;
+}
+
+static void
+update_dialog_state (PpNewPrinterDialog *self)
+{
+  GtkTreeIter                iter;
+  gboolean                   searching;
+
+  searching = self->cups_searching ||
+              self->remote_cups_host != NULL ||
+              self->snmp_host != NULL ||
+              self->socket_host != NULL ||
+              self->lpd_host != NULL ||
+              self->samba_host != NULL ||
+              self->samba_authenticated_searching ||
+              self->samba_searching;
+
+  if (searching)
+    {
+      adw_window_title_set_subtitle (self->header_title, _("Searching for Printers"));
+    }
+  else
+    {
+      adw_window_title_set_subtitle (self->header_title, NULL);
+    }
+
+  if (gtk_tree_model_get_iter_first (GTK_TREE_MODEL (self->devices_liststore), &iter))
+      gtk_stack_set_visible_child_name (self->stack, "standard-page");
+  else
+      gtk_stack_set_visible_child_name (self->stack, searching ? "loading-page" : "no-printers-page");
+}
+
+static void
+group_physical_devices_cb (gchar    ***device_uris,
+                           gpointer    user_data)
+{
+  PpNewPrinterDialog        *self = user_data;
+  gint                       i, j;
+
+  if (device_uris != NULL)
+    {
+      for (i = 0; device_uris[i] != NULL; i++)
+        {
+          /* Is there any device in this sublist? */
+          if (device_uris[i][0] != NULL)
+            {
+              g_autoptr(PpPrintDevice) device = NULL;
+
+              for (j = 0; device_uris[i][j] != NULL; j++)
+                {
+                  device = device_in_liststore (device_uris[i][j], self->devices_liststore);
+                  if (device != NULL)
+                    break;
+                }
+
+              /* Is this sublist represented in the current list of devices? */
+              if (device != NULL)
+                {
+                  /* Is there better device in the sublist? */
+                  if (j != 0)
+                    {
+                      g_autoptr(PpPrintDevice) better_device = NULL;
+
+                      better_device = device_in_list (device_uris[i][0], self->local_cups_devices);
+                      replace_device (self, device, better_device);
+                    }
+                }
+              else
+                {
+                  device = device_in_list (device_uris[i][0], self->local_cups_devices);
+                  if (device != NULL)
+                    set_device (self, device, NULL);
+                }
+            }
+        }
+
+      for (i = 0; device_uris[i] != NULL; i++)
+        g_strfreev (device_uris[i]);
+
+      g_free (device_uris);
+    }
+  else
+    {
+      for (i = 0; i < self->local_cups_devices->len; i++)
+        set_device (self, g_ptr_array_index (self->local_cups_devices, i), NULL);
+      g_ptr_array_set_size (self->local_cups_devices, 0);
+    }
+
+  update_dialog_state (self);
+}
+
+static void
+group_physical_devices_dbus_cb (GObject      *source_object,
+                                GAsyncResult *res,
+                                gpointer      user_data)
+{
+  g_autoptr(GVariant) output = NULL;
+  g_autoptr(GError)   error = NULL;
+  gchar            ***result = NULL;
+  gint                i;
+
+  output = g_dbus_connection_call_finish (G_DBUS_CONNECTION (source_object),
+                                          res,
+                                          &error);
+
+  if (output)
+    {
+      g_autoptr(GVariant) array = NULL;
+
+      g_variant_get (output, "(@aas)", &array);
+
+      if (array)
+        {
+          g_autoptr(GVariantIter) iter = NULL;
+          GStrv device_uris;
+
+          result = g_new0 (gchar **, g_variant_n_children (array) + 1);
+          g_variant_get (array, "aas", &iter);
+          i = 0;
+          while (g_variant_iter_next (iter, "^as", &device_uris))
+            {
+              result[i] = device_uris;
+              i++;
+            }
+        }
+    }
+  else if (error &&
+           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 \"GroupPhysicalDevices\" to group duplicates in device list.");
+    }
+  else
+    {
+      if (!g_error_matches (error, G_IO_ERROR, G_IO_ERROR_CANCELLED))
+        g_warning ("%s", error->message);
+    }
+
+  if (!g_error_matches (error, G_IO_ERROR, G_IO_ERROR_CANCELLED))
+    group_physical_devices_cb (result, user_data);
+}
+
+static void
+get_cups_devices_cb (GPtrArray *devices,
+                     gboolean  finished,
+                     gboolean  cancelled,
+                     gpointer  user_data)
+{
+  PpNewPrinterDialog         *self = user_data;
+  g_autoptr(GDBusConnection)  bus = NULL;
+  GVariantBuilder             device_list;
+  GVariantBuilder             device_hash;
+  PpPrintDevice             **all_devices;
+  const gchar                *device_class;
+  GtkTreeIter                 iter;
+  gboolean                    cont;
+  g_autoptr(GError)           error = NULL;
+  gint                        length, i;
+
+
+  if (!cancelled)
+    {
+      if (finished)
+        {
+          self->cups_searching = FALSE;
+        }
+
+      if (devices != NULL)
+        {
+          add_devices_to_list (self, devices);
+
+          length = gtk_tree_model_iter_n_children (GTK_TREE_MODEL (self->devices_liststore), NULL) + self->local_cups_devices->len;
+          if (length > 0)
+            {
+              all_devices = g_new0 (PpPrintDevice *, length);
+
+              i = 0;
+              cont = gtk_tree_model_get_iter_first (GTK_TREE_MODEL (self->devices_liststore), &iter);
+              while (cont)
+                {
+                  g_autoptr(PpPrintDevice) device = NULL;
+
+                  gtk_tree_model_get (GTK_TREE_MODEL (self->devices_liststore), &iter,
+                                      DEVICE_COLUMN, &device,
+                                      -1);
+
+                  all_devices[i] = g_object_new (PP_TYPE_PRINT_DEVICE,
+                                                 "device-id", pp_print_device_get_device_id (device),
+                                                 "device-make-and-model", pp_print_device_get_device_make_and_model (device),
+                                                 "is-network-device", pp_print_device_is_network_device (device),
+                                                 "device-uri", pp_print_device_get_device_uri (device),
+                                                 NULL);
+                  i++;
+
+                  cont = gtk_tree_model_iter_next (GTK_TREE_MODEL (self->devices_liststore), &iter);
+                }
+
+              for (guint j = 0; j < self->local_cups_devices->len; j++)
+                {
+                  PpPrintDevice *pp_device = g_ptr_array_index (self->local_cups_devices, j);
+                  all_devices[i] = g_object_new (PP_TYPE_PRINT_DEVICE,
+                                                 "device-id", pp_print_device_get_device_id (pp_device),
+                                                 "device-make-and-model", pp_print_device_get_device_make_and_model (pp_device),
+                                                 "is-network-device", pp_print_device_is_network_device (pp_device),
+                                                 "device-uri", pp_print_device_get_device_uri (pp_device),
+                                                 NULL);
+                   i++;
+                }
+
+              bus = g_bus_get_sync (G_BUS_TYPE_SESSION, NULL, &error);
+              if (bus)
+                {
+                  g_variant_builder_init (&device_list, G_VARIANT_TYPE ("a{sv}"));
+
+                  for (i = 0; i < length; i++)
+                    {
+                      if (pp_print_device_get_device_uri (all_devices[i]))
+                        {
+                          g_variant_builder_init (&device_hash, G_VARIANT_TYPE ("a{ss}"));
+
+                          if (pp_print_device_get_device_id (all_devices[i]))
+                            g_variant_builder_add (&device_hash,
+                                                   "{ss}",
+                                                   "device-id",
+                                                   pp_print_device_get_device_id (all_devices[i]));
+
+                          if (pp_print_device_get_device_make_and_model (all_devices[i]))
+                            g_variant_builder_add (&device_hash,
+                                                   "{ss}",
+                                                   "device-make-and-model",
+                                                   pp_print_device_get_device_make_and_model (all_devices[i]));
+
+                          if (pp_print_device_is_network_device (all_devices[i]))
+                            device_class = "network";
+                          else
+                            device_class = "direct";
+
+                          g_variant_builder_add (&device_hash,
+                                                 "{ss}",
+                                                 "device-class",
+                                                 device_class);
+
+                          g_variant_builder_add (&device_list,
+                                                 "{sv}",
+                                                 pp_print_device_get_device_uri (all_devices[i]),
+                                                 g_variant_builder_end (&device_hash));
+                        }
+                    }
+
+                  g_dbus_connection_call (bus,
+                                          SCP_BUS,
+                                          SCP_PATH,
+                                          SCP_IFACE,
+                                          "GroupPhysicalDevices",
+                                          g_variant_new ("(v)", g_variant_builder_end (&device_list)),
+                                          G_VARIANT_TYPE ("(aas)"),
+                                          G_DBUS_CALL_FLAGS_NONE,
+                                          -1,
+                                          self->cancellable,
+                                          group_physical_devices_dbus_cb,
+                                          self);
+                }
+              else
+                {
+                  g_warning ("Failed to get system bus: %s", error->message);
+                  group_physical_devices_cb (NULL, user_data);
+                }
+
+              for (i = 0; i < length; i++)
+                g_object_unref (all_devices[i]);
+              g_free (all_devices);
+            }
+          else
+            {
+              update_dialog_state (self);
+            }
+        }
+      else
+        {
+          update_dialog_state (self);
+        }
+    }
+}
+
+static void
+get_snmp_devices_cb (GObject      *source_object,
+                     GAsyncResult *res,
+                     gpointer      user_data)
+{
+  PpNewPrinterDialog        *self = user_data;
+  g_autoptr(GError)          error = NULL;
+  g_autoptr(GPtrArray)       devices = NULL;
+
+  devices = pp_host_get_snmp_devices_finish (PP_HOST (source_object), res, &error);
+
+  if (devices != NULL)
+    {
+      g_clear_object(&self->snmp_host);
+
+      add_devices_to_list (self, devices);
+
+      update_dialog_state (self);
+    }
+  else
+    {
+      if (!g_error_matches (error, G_IO_ERROR, G_IO_ERROR_CANCELLED))
+        {
+          g_warning ("%s", error->message);
+
+          g_clear_object(&self->snmp_host);
+
+          update_dialog_state (self);
+        }
+    }
+}
+
+static void
+get_remote_cups_devices_cb (GObject      *source_object,
+                            GAsyncResult *res,
+                            gpointer      user_data)
+{
+  PpNewPrinterDialog        *self = user_data;
+  g_autoptr(GError)          error = NULL;
+  g_autoptr(GPtrArray)       devices = NULL;
+
+  devices = pp_host_get_remote_cups_devices_finish (PP_HOST (source_object), res, &error);
+
+  if (devices != NULL)
+    {
+      g_clear_object(&self->remote_cups_host);
+
+      add_devices_to_list (self, devices);
+
+      update_dialog_state (self);
+    }
+  else
+    {
+      if (!g_error_matches (error, G_IO_ERROR, G_IO_ERROR_CANCELLED))
+        {
+          g_warning ("%s", error->message);
+
+          g_clear_object(&self->remote_cups_host);
+
+          update_dialog_state (self);
+        }
+    }
+}
+
+static void
+get_samba_host_devices_cb (GObject      *source_object,
+                           GAsyncResult *res,
+                           gpointer      user_data)
+{
+  PpNewPrinterDialog        *self = user_data;
+  g_autoptr(GPtrArray)       devices = NULL;
+  g_autoptr(GError)          error = NULL;
+
+  devices = pp_samba_get_devices_finish (PP_SAMBA (source_object), res, &error);
+
+  if (devices != NULL)
+    {
+      g_clear_object(&self->samba_host);
+
+      add_devices_to_list (self, devices);
+
+      update_dialog_state (self);
+    }
+  else
+    {
+      if (!g_error_matches (error, G_IO_ERROR, G_IO_ERROR_CANCELLED))
+        {
+          g_warning ("%s", error->message);
+
+          g_clear_object(&self->samba_host);
+
+          update_dialog_state (self);
+        }
+    }
+}
+
+static void
+get_samba_devices_cb (GObject      *source_object,
+                      GAsyncResult *res,
+                      gpointer      user_data)
+{
+  PpNewPrinterDialog        *self = user_data;
+  g_autoptr(GPtrArray)       devices = NULL;
+  g_autoptr(GError)          error = NULL;
+
+  devices = pp_samba_get_devices_finish (PP_SAMBA (source_object), res, &error);
+
+  if (devices != NULL)
+    {
+      self->samba_searching = FALSE;
+
+      add_devices_to_list (self, devices);
+
+      update_dialog_state (self);
+    }
+  else
+    {
+      if (!g_error_matches (error, G_IO_ERROR, G_IO_ERROR_CANCELLED))
+        {
+          g_warning ("%s", error->message);
+
+          self->samba_searching = FALSE;
+
+          update_dialog_state (self);
+        }
+    }
+}
+
+static void
+get_jetdirect_devices_cb (GObject      *source_object,
+                          GAsyncResult *res,
+                          gpointer      user_data)
+{
+  PpNewPrinterDialog        *self = user_data;
+  g_autoptr(GError)          error = NULL;
+  g_autoptr(GPtrArray)       devices = NULL;
+
+  devices = pp_host_get_jetdirect_devices_finish (PP_HOST (source_object), res, &error);
+
+  if (devices != NULL)
+    {
+      g_clear_object(&self->socket_host);
+
+      add_devices_to_list (self, devices);
+
+      update_dialog_state (self);
+    }
+  else
+    {
+      if (!g_error_matches (error, G_IO_ERROR, G_IO_ERROR_CANCELLED))
+        {
+          g_warning ("%s", error->message);
+
+          g_clear_object(&self->socket_host);
+
+          update_dialog_state (self);
+        }
+    }
+}
+
+static void
+get_lpd_devices_cb (GObject      *source_object,
+                    GAsyncResult *res,
+                    gpointer      user_data)
+{
+  PpNewPrinterDialog        *self = user_data;
+  g_autoptr(GError)          error = NULL;
+  g_autoptr(GPtrArray)       devices = NULL;
+
+  devices = pp_host_get_lpd_devices_finish (PP_HOST (source_object), res, &error);
+
+  if (devices != NULL)
+    {
+      g_clear_object(&self->lpd_host);
+
+      add_devices_to_list (self, devices);
+
+      update_dialog_state (self);
+    }
+  else
+    {
+      if (!g_error_matches (error, G_IO_ERROR, G_IO_ERROR_CANCELLED))
+        {
+          g_warning ("%s", error->message);
+
+          g_clear_object(&self->lpd_host);
+
+          update_dialog_state (self);
+        }
+    }
+}
+
+static void
+get_cups_devices (PpNewPrinterDialog *self)
+{
+  self->cups_searching = TRUE;
+  update_dialog_state (self);
+
+  get_cups_devices_async (self->cancellable,
+                          get_cups_devices_cb,
+                          self);
+}
+
+static gboolean
+parse_uri (const gchar  *uri,
+           gchar       **scheme,
+           gchar       **host,
+           gint         *port)
+{
+  const gchar      *tmp = NULL;
+  g_autofree gchar *resulting_host = NULL;
+  gchar            *position;
+
+  *port = PP_HOST_UNSET_PORT;
+
+  position = g_strrstr (uri, "://");
+  if (position != NULL)
+    {
+      *scheme = g_strndup (uri, position - uri);
+      tmp = position + 3;
+    }
+  else
+    {
+      tmp = uri;
+    }
+
+  if (g_strrstr (tmp, "@"))
+    tmp = g_strrstr (tmp, "@") + 1;
+
+  if ((position = g_strrstr (tmp, "/")))
+    {
+      *position = '\0';
+      resulting_host = g_strdup (tmp);
+      *position = '/';
+    }
+  else
+    {
+      resulting_host = g_strdup (tmp);
+    }
+
+  if ((position = g_strrstr (resulting_host, ":")))
+    {
+      *position = '\0';
+      *port = atoi (position + 1);
+    }
+
+  *host = g_uri_unescape_string (resulting_host,
+                                 G_URI_RESERVED_CHARS_GENERIC_DELIMITERS
+                                 G_URI_RESERVED_CHARS_SUBCOMPONENT_DELIMITERS);
+
+  return TRUE;
+}
+
+typedef struct
+{
+  PpNewPrinterDialog *dialog;
+  gchar              *host_scheme;
+  gchar              *host_name;
+  gint                host_port;
+} THostSearchData;
+
+static void
+search_for_remote_printers_free (THostSearchData *data)
+{
+  g_free (data->host_scheme);
+  g_free (data->host_name);
+  g_free (data);
+}
+
+static gboolean
+search_for_remote_printers (THostSearchData *data)
+{
+  PpNewPrinterDialog *self = data->dialog;
+
+  g_cancellable_cancel (self->remote_host_cancellable);
+  g_clear_object (&self->remote_host_cancellable);
+
+  self->remote_host_cancellable = g_cancellable_new ();
+
+  self->remote_cups_host = pp_host_new (data->host_name);
+  self->snmp_host = pp_host_new (data->host_name);
+  self->socket_host = pp_host_new (data->host_name);
+  self->lpd_host = pp_host_new (data->host_name);
+
+  if (data->host_port != PP_HOST_UNSET_PORT)
+    {
+      g_object_set (self->remote_cups_host, "port", data->host_port, NULL);
+      g_object_set (self->snmp_host, "port", data->host_port, NULL);
+
+      /* Accept port different from the default one only if user specifies
+       * scheme (for socket and lpd printers).
+       */
+      if (data->host_scheme != NULL &&
+          g_ascii_strcasecmp (data->host_scheme, "socket") == 0)
+        g_object_set (self->socket_host, "port", data->host_port, NULL);
+
+      if (data->host_scheme != NULL &&
+          g_ascii_strcasecmp (data->host_scheme, "lpd") == 0)
+        g_object_set (self->lpd_host, "port", data->host_port, NULL);
+    }
+
+  self->samba_host = pp_samba_new (data->host_name);
+
+  update_dialog_state (data->dialog);
+
+  pp_host_get_remote_cups_devices_async (self->remote_cups_host,
+                                         self->remote_host_cancellable,
+                                         get_remote_cups_devices_cb,
+                                         data->dialog);
+
+  pp_host_get_snmp_devices_async (self->snmp_host,
+                                  self->remote_host_cancellable,
+                                  get_snmp_devices_cb,
+                                  data->dialog);
+
+  pp_host_get_jetdirect_devices_async (self->socket_host,
+                                       self->remote_host_cancellable,
+                                       get_jetdirect_devices_cb,
+                                       data->dialog);
+
+  pp_host_get_lpd_devices_async (self->lpd_host,
+                                 self->remote_host_cancellable,
+                                 get_lpd_devices_cb,
+                                 data->dialog);
+
+  pp_samba_get_devices_async (self->samba_host,
+                              FALSE,
+                              self->remote_host_cancellable,
+                              get_samba_host_devices_cb,
+                              data->dialog);
+
+  self->host_search_timeout_id = 0;
+
+  return G_SOURCE_REMOVE;
+}
+
+static void
+search_address (const gchar        *text,
+                PpNewPrinterDialog *self,
+                gboolean            delay_search)
+{
+  GtkTreeIter                 iter;
+  gboolean                    found = FALSE;
+  gboolean                    subfound;
+  gboolean                    next_set;
+  gboolean                    cont;
+  g_autofree gchar           *lowercase_text = NULL;
+  gchar                     **words;
+  gint                        words_length = 0;
+  gint                        i;
+  gint                        acquisition_method;
+
+  lowercase_text = g_ascii_strdown (text, -1);
+  words = g_strsplit_set (lowercase_text, " ", -1);
+
+  if (words)
+    {
+      words_length = g_strv_length (words);
+
+      cont = gtk_tree_model_get_iter_first (GTK_TREE_MODEL (self->devices_liststore), &iter);
+      while (cont)
+        {
+          g_autoptr(PpPrintDevice) device = NULL;
+          g_autofree gchar *lowercase_name = NULL;
+          g_autofree gchar *lowercase_location = NULL;
+
+          gtk_tree_model_get (GTK_TREE_MODEL (self->devices_liststore), &iter,
+                              DEVICE_COLUMN, &device,
+                              -1);
+
+          lowercase_name = g_ascii_strdown (pp_print_device_get_device_name (device), -1);
+          if (pp_print_device_get_device_location (device))
+            lowercase_location = g_ascii_strdown (pp_print_device_get_device_location (device), -1);
+          else
+            lowercase_location = NULL;
+
+          subfound = TRUE;
+          for (i = 0; words[i]; i++)
+            {
+              if (!g_strrstr (lowercase_name, words[i]) &&
+                  (!lowercase_location || !g_strrstr (lowercase_location, words[i])))
+                subfound = FALSE;
+            }
+
+          if (subfound)
+            found = TRUE;
+
+          gtk_list_store_set (GTK_LIST_STORE (self->devices_liststore), &iter,
+                              DEVICE_VISIBLE_COLUMN, subfound,
+                              -1);
+
+          cont = gtk_tree_model_iter_next (GTK_TREE_MODEL (self->devices_liststore), &iter);
+        }
+
+      g_strfreev (words);
+  }
+
+  /*
+   * The given word is probably an address since it was not found among
+   * already present devices.
+   */
+  if (!found && words_length == 1)
+    {
+      cont = gtk_tree_model_get_iter_first (GTK_TREE_MODEL (self->devices_liststore), &iter);
+      while (cont)
+        {
+          g_autoptr(PpPrintDevice) device = NULL;
+
+          next_set = FALSE;
+          gtk_tree_model_get (GTK_TREE_MODEL (self->devices_liststore), &iter,
+                              DEVICE_COLUMN, &device,
+                              -1);
+
+          gtk_list_store_set (GTK_LIST_STORE (self->devices_liststore), &iter,
+                              DEVICE_VISIBLE_COLUMN, TRUE,
+                              -1);
+
+          acquisition_method = pp_print_device_get_acquisition_method (device);
+          if (acquisition_method == ACQUISITION_METHOD_REMOTE_CUPS_SERVER ||
+              acquisition_method == ACQUISITION_METHOD_SNMP ||
+              acquisition_method == ACQUISITION_METHOD_JETDIRECT ||
+              acquisition_method == ACQUISITION_METHOD_LPD ||
+              acquisition_method == ACQUISITION_METHOD_SAMBA_HOST)
+            {
+              if (!gtk_list_store_remove (self->devices_liststore, &iter))
+                break;
+              else
+                next_set = TRUE;
+            }
+
+          if (!next_set)
+            cont = gtk_tree_model_iter_next (GTK_TREE_MODEL (self->devices_liststore), &iter);
+        }
+
+      if (text && text[0] != '\0')
+        {
+          g_autoptr(GSocketConnectable) conn = NULL;
+          g_autofree gchar *test_uri = NULL;
+          g_autofree gchar *test_port = NULL;
+          gchar *scheme = NULL;
+          gchar *host = NULL;
+          gint   port;
+
+          parse_uri (text, &scheme, &host, &port);
+
+          if (host != NULL)
+            {
+              if (port >= 0)
+                test_port = g_strdup_printf (":%d", port);
+              else
+                test_port = g_strdup ("");
+
+              test_uri = g_strdup_printf ("%s://%s%s",
+                                          scheme != NULL && scheme[0] != '\0' ? scheme : "none",
+                                          host,
+                                          test_port);
+
+              conn = g_network_address_parse_uri (test_uri, 0, NULL);
+              if (conn != NULL)
+                {
+                  THostSearchData *search_data;
+
+                  search_data = g_new (THostSearchData, 1);
+                  search_data->host_scheme = scheme;
+                  search_data->host_name = host;
+                  search_data->host_port = port;
+                  search_data->dialog = self;
+
+                  if (self->host_search_timeout_id != 0)
+                    {
+                      g_source_remove (self->host_search_timeout_id);
+                      self->host_search_timeout_id = 0;
+                    }
+
+                  if (delay_search)
+                    {
+                      self->host_search_timeout_id = g_timeout_add_full (G_PRIORITY_DEFAULT,
+                                                                         HOST_SEARCH_DELAY,
+                                                                         (GSourceFunc) search_for_remote_printers,
+                                                                         search_data,
+                                                                         (GDestroyNotify) search_for_remote_printers_free);
+                    }
+                  else
+                    {
+                      search_for_remote_printers (search_data);
+                      search_for_remote_printers_free (search_data);
+                    }
+                }
+            }
+        }
+    }
+}
+
+static void
+search_entry_activated_cb (PpNewPrinterDialog *self)
+{
+  search_address (gtk_editable_get_text (GTK_EDITABLE (self->search_entry)),
+                  self,
+                  FALSE);
+}
+
+static void
+search_entry_changed_cb (PpNewPrinterDialog *self)
+{
+  search_address (gtk_editable_get_text (GTK_EDITABLE (self->search_entry)),
+                  self,
+                  TRUE);
+}
+
+static gchar *
+get_local_scheme_description_from_uri (gchar *device_uri)
+{
+  gchar *description = NULL;
+
+  if (device_uri != NULL)
+    {
+      if (g_str_has_prefix (device_uri, "usb") ||
+          g_str_has_prefix (device_uri, "hp:/usb/") ||
+          g_str_has_prefix (device_uri, "hpfax:/usb/"))
+        {
+          /* Translators: The found device is a printer connected via USB */
+          description = g_strdup (_("USB"));
+        }
+      else if (g_str_has_prefix (device_uri, "serial"))
+        {
+          /* Translators: The found device is a printer connected via serial port */
+          description = g_strdup (_("Serial Port"));
+        }
+      else if (g_str_has_prefix (device_uri, "parallel") ||
+               g_str_has_prefix (device_uri, "hp:/par/") ||
+               g_str_has_prefix (device_uri, "hpfax:/par/"))
+        {
+          /* Translators: The found device is a printer connected via parallel port */
+          description = g_strdup (_("Parallel Port"));
+        }
+      else if (g_str_has_prefix (device_uri, "bluetooth"))
+        {
+          /* Translators: The found device is a printer connected via Bluetooth */
+          description = g_strdup (_("Bluetooth"));
+        }
+    }
+
+  return description;
+}
+
+static void
+set_device (PpNewPrinterDialog *self,
+            PpPrintDevice      *device,
+            GtkTreeIter        *iter)
+{
+  GtkTreeIter                titer;
+  gint                       acquisition_method;
+
+  if (device != NULL)
+    {
+      acquisition_method = pp_print_device_get_acquisition_method (device);
+      if (pp_print_device_get_display_name (device) &&
+          (pp_print_device_get_device_id (device) ||
+           pp_print_device_get_device_ppd (device) ||
+           (pp_print_device_get_host_name (device) &&
+            acquisition_method == ACQUISITION_METHOD_REMOTE_CUPS_SERVER) ||
+           (pp_print_device_get_device_uri (device) &&
+            (acquisition_method == ACQUISITION_METHOD_JETDIRECT ||
+             acquisition_method == ACQUISITION_METHOD_LPD)) ||
+           acquisition_method == ACQUISITION_METHOD_SAMBA_HOST ||
+           acquisition_method == ACQUISITION_METHOD_SAMBA))
+        {
+          g_autofree gchar *description = NULL;
+
+          description = get_local_scheme_description_from_uri (pp_print_device_get_device_uri (device));
+          if (description == NULL)
+            {
+              if (pp_print_device_get_device_location (device) != NULL && pp_print_device_get_device_location (device)[0] != '\0')
+                {
+                  /* Translators: Location of found network printer (e.g. Kitchen, Reception) */
+                  description = g_strdup_printf (_("Location: %s"), pp_print_device_get_device_location (device));
+                }
+              else if (pp_print_device_get_host_name (device) != NULL && pp_print_device_get_host_name (device)[0] != '\0')
+                {
+                  /* Translators: Network address of found printer */
+                  description = g_strdup_printf (_("Address: %s"), pp_print_device_get_host_name (device));
+                }
+            }
+
+          if (iter == NULL)
+            gtk_list_store_append (self->devices_liststore, &titer);
+
+          gtk_list_store_set (self->devices_liststore, iter == NULL ? &titer : iter,
+                              DEVICE_GICON_COLUMN, pp_print_device_is_network_device (device) ? self->remote_printer_icon : self->local_printer_icon,
+                              DEVICE_NAME_COLUMN, pp_print_device_get_device_name (device),
+                              DEVICE_DISPLAY_NAME_COLUMN, pp_print_device_get_display_name (device),
+                              DEVICE_DESCRIPTION_COLUMN, description,
+                              DEVICE_VISIBLE_COLUMN, TRUE,
+                              DEVICE_COLUMN, device,
+                              -1);
+        }
+      else if (pp_print_device_is_authenticated_server (device) &&
+               pp_print_device_get_host_name (device) != NULL)
+        {
+          if (iter == NULL)
+            gtk_list_store_append (self->devices_liststore, &titer);
+
+          gtk_list_store_set (self->devices_liststore, iter == NULL ? &titer : iter,
+                              DEVICE_GICON_COLUMN, self->authenticated_server_icon,
+                              DEVICE_NAME_COLUMN, pp_print_device_get_host_name (device),
+                              DEVICE_DISPLAY_NAME_COLUMN, pp_print_device_get_host_name (device),
+                              /* Translators: This item is a server which needs authentication to show its printers */
+                              DEVICE_DESCRIPTION_COLUMN, _("Server requires authentication"),
+                              SERVER_NEEDS_AUTHENTICATION_COLUMN, TRUE,
+                              DEVICE_VISIBLE_COLUMN, TRUE,
+                              DEVICE_COLUMN, device,
+                              -1);
+        }
+    }
+}
+
+static void
+replace_device (PpNewPrinterDialog *self,
+                PpPrintDevice      *old_device,
+                PpPrintDevice      *new_device)
+{
+  GtkTreeIter                iter;
+  gboolean                   cont;
+
+  if (old_device != NULL && new_device != NULL)
+    {
+      cont = gtk_tree_model_get_iter_first (GTK_TREE_MODEL (self->devices_liststore), &iter);
+      while (cont)
+        {
+          g_autoptr(PpPrintDevice) device = NULL;
+
+          gtk_tree_model_get (GTK_TREE_MODEL (self->devices_liststore), &iter,
+                              DEVICE_COLUMN, &device,
+                              -1);
+
+          if (old_device == device)
+            {
+              set_device (self, new_device, &iter);
+              break;
+            }
+
+          cont = gtk_tree_model_iter_next (GTK_TREE_MODEL (self->devices_liststore), &iter);
+        }
+    }
+}
+
+static void
+cups_get_dests_cb (GObject      *source_object,
+                   GAsyncResult *res,
+                   gpointer      user_data)
+{
+  PpNewPrinterDialog        *self = user_data;
+  PpCupsDests               *dests;
+  g_autoptr(GError)          error = NULL;
+
+  dests = pp_cups_get_dests_finish (PP_CUPS (source_object), res, &error);
+
+  if (dests)
+    {
+      self->dests = dests->dests;
+      self->num_of_dests = dests->num_of_dests;
+
+      get_cups_devices (self);
+    }
+  else
+    {
+      if (!g_error_matches (error, G_IO_ERROR, G_IO_ERROR_CANCELLED))
+        {
+          g_warning ("%s", error->message);
+
+          get_cups_devices (self);
+        }
+    }
+}
+
+static void
+row_activated_cb (PpNewPrinterDialog *self)
+{
+  GtkTreeModel              *model;
+  GtkTreeIter                iter;
+  gboolean                   authentication_needed;
+  gboolean                   selected;
+
+  selected = gtk_tree_selection_get_selected (gtk_tree_view_get_selection (self->devices_treeview),
+                                              &model,
+                                              &iter);
+
+  if (selected)
+    {
+      gtk_tree_model_get (model, &iter, SERVER_NEEDS_AUTHENTICATION_COLUMN, &authentication_needed, -1);
+
+      if (authentication_needed)
+        {
+          authenticate_samba_server (self);
+        }
+      else
+        {
+          gtk_dialog_response (GTK_DIALOG (self), GTK_RESPONSE_OK);
+        }
+    }
+}
+
+static void
+cell_data_func (GtkTreeViewColumn  *tree_column,
+                GtkCellRenderer    *cell,
+                GtkTreeModel       *tree_model,
+                GtkTreeIter        *iter,
+                gpointer            user_data)
+{
+  PpNewPrinterDialog        *self = user_data;
+  gboolean                   selected = FALSE;
+  g_autofree gchar          *name = NULL;
+  g_autofree gchar          *description = NULL;
+
+  selected = gtk_tree_selection_iter_is_selected (gtk_tree_view_get_selection (self->devices_treeview), iter);
+
+  gtk_tree_model_get (tree_model, iter,
+                      DEVICE_DISPLAY_NAME_COLUMN, &name,
+                      DEVICE_DESCRIPTION_COLUMN, &description,
+                      -1);
+
+  if (name != NULL)
+    {
+      g_autofree gchar *text = NULL;
+
+      if (description != NULL)
+        {
+          if (selected)
+            text = g_markup_printf_escaped ("<b>%s</b>\n<small>%s</small>",
+                                            name,
+                                            description);
+          else
+            text = g_markup_printf_escaped ("<b>%s</b>\n<small><span foreground=\"#555555\">%s</span></small>",
+                                            name,
+                                            description);
+        }
+      else
+        {
+          text = g_markup_printf_escaped ("<b>%s</b>\n ",
+                                          name);
+        }
+
+      g_object_set (G_OBJECT (cell),
+                    "markup", text,
+                    NULL);
+    }
+}
+
+static void
+populate_devices_list (PpNewPrinterDialog *self)
+{
+  GtkTreeViewColumn         *column;
+  g_autoptr(PpSamba)         samba = NULL;
+  g_autoptr(GEmblem)         emblem = NULL;
+  g_autoptr(PpCups)          cups = NULL;
+  g_autoptr(GIcon)           icon = NULL;
+  g_autoptr(GIcon)           emblem_icon = NULL;
+  GtkCellRenderer           *text_renderer;
+  GtkCellRenderer           *icon_renderer;
+
+  g_signal_connect_object (gtk_tree_view_get_selection (self->devices_treeview),
+                           "changed", G_CALLBACK (device_selection_changed_cb), self, G_CONNECT_SWAPPED);
+
+  g_signal_connect_object (self->devices_treeview,
+                           "row-activated", G_CALLBACK (row_activated_cb), self, G_CONNECT_SWAPPED);
+
+  self->local_printer_icon = g_themed_icon_new ("printer");
+  self->remote_printer_icon = g_themed_icon_new ("printer-network");
+
+  icon = g_themed_icon_new ("network-server");
+  emblem_icon = g_themed_icon_new ("changes-prevent");
+  emblem = g_emblem_new (emblem_icon);
+
+  self->authenticated_server_icon = g_emblemed_icon_new (icon, emblem);
+
+  icon_renderer = gtk_cell_renderer_pixbuf_new ();
+  g_object_set (icon_renderer, "icon-size", GTK_ICON_SIZE_LARGE, NULL);
+  gtk_cell_renderer_set_alignment (icon_renderer, 1.0, 0.5);
+  gtk_cell_renderer_set_padding (icon_renderer, 4, 4);
+  column = gtk_tree_view_column_new_with_attributes ("Icon", icon_renderer,
+                                                     "gicon", DEVICE_GICON_COLUMN, NULL);
+  gtk_tree_view_column_set_max_width (column, -1);
+  gtk_tree_view_column_set_min_width (column, 80);
+  gtk_tree_view_append_column (self->devices_treeview, column);
+
+
+  text_renderer = gtk_cell_renderer_text_new ();
+  column = gtk_tree_view_column_new_with_attributes ("Devices", text_renderer,
+                                                     NULL);
+  gtk_tree_view_column_set_cell_data_func (column, text_renderer, cell_data_func,
+                                           self, NULL);
+  gtk_tree_view_append_column (self->devices_treeview, column);
+
+  gtk_tree_model_filter_set_visible_column (self->devices_model_filter, DEVICE_VISIBLE_COLUMN);
+
+  cups = pp_cups_new ();
+  pp_cups_get_dests_async (cups, self->cancellable, cups_get_dests_cb, self);
+
+  self->samba_searching = TRUE;
+  update_dialog_state (self);
+
+  samba = pp_samba_new (NULL);
+  pp_samba_get_devices_async (samba, FALSE, self->cancellable, get_samba_devices_cb, self);
+}
+
+static void
+ppd_selection_cb (GtkDialog *_dialog,
+                  gint       response_id,
+                  gpointer   user_data)
+{
+  PpNewPrinterDialog        *self = user_data;
+  GList                     *original_names_list = NULL;
+  g_autofree gchar          *ppd_name = NULL;
+  g_autofree gchar          *ppd_display_name = NULL;
+  gint                       acquisition_method;
+
+  if (response_id == GTK_RESPONSE_OK) {
+      ppd_name = pp_ppd_selection_dialog_get_ppd_name (self->ppd_selection_dialog);
+      ppd_display_name = pp_ppd_selection_dialog_get_ppd_display_name (self->ppd_selection_dialog);
+  }
+
+  if (ppd_name)
+    {
+      g_object_set (self->new_device, "device-ppd", ppd_name, NULL);
+
+      acquisition_method = pp_print_device_get_acquisition_method (self->new_device);
+      if ((acquisition_method == ACQUISITION_METHOD_JETDIRECT ||
+           acquisition_method == ACQUISITION_METHOD_LPD) &&
+          ppd_display_name != NULL)
+        {
+          g_autofree gchar *printer_name = NULL;
+
+          g_object_set (self->new_device,
+                        "device-name", ppd_display_name,
+                        "device-original-name", ppd_display_name,
+                        NULL);
+
+          gtk_tree_model_foreach (GTK_TREE_MODEL (self->devices_liststore),
+                                  prepend_original_name,
+                                  &original_names_list);
+
+          original_names_list = g_list_reverse (original_names_list);
+
+          printer_name = canonicalize_device_name (original_names_list,
+                                                   self->local_cups_devices,
+                                                   self->dests,
+                                                   self->num_of_dests,
+                                                   self->new_device);
+
+          g_list_free_full (original_names_list, g_free);
+
+          g_object_set (self->new_device,
+                        "device-name", printer_name,
+                        "device-original-name", printer_name,
+                        NULL);
+        }
+    }
+
+  /* This is needed here since parent dialog is destroyed first. */
+  gtk_window_set_transient_for (GTK_WINDOW (self->ppd_selection_dialog), NULL);
+
+  self->user_callback (GTK_DIALOG (self), response_id, self->user_data);
+}
+
+static void
+new_printer_dialog_response_cb (PpNewPrinterDialog *self,
+                                gint                response_id)
+{
+  g_autoptr(PpPrintDevice)   device = NULL;
+  GtkTreeModel              *model;
+  GtkTreeIter                iter;
+  gint                       acquisition_method;
+
+  if (response_id == GTK_RESPONSE_OK)
+    {
+      g_cancellable_cancel (self->cancellable);
+      g_clear_object (&self->cancellable);
+
+      if (gtk_tree_selection_get_selected (gtk_tree_view_get_selection (self->devices_treeview), &model, &iter))
+        {
+          gtk_tree_model_get (model, &iter,
+                              DEVICE_COLUMN, &device,
+                              -1);
+        }
+
+      if (device)
+        {
+          acquisition_method = pp_print_device_get_acquisition_method (device);
+          if (acquisition_method == ACQUISITION_METHOD_SAMBA ||
+              acquisition_method == ACQUISITION_METHOD_SAMBA_HOST ||
+              acquisition_method == ACQUISITION_METHOD_JETDIRECT ||
+              acquisition_method == ACQUISITION_METHOD_LPD)
+            {
+              self->new_device = pp_print_device_copy (device);
+              self->ppd_selection_dialog =
+                pp_ppd_selection_dialog_new (self->list,
+                                             NULL,
+                                             ppd_selection_cb,
+                                             self);
+
+              gtk_window_set_transient_for (GTK_WINDOW (self->ppd_selection_dialog),
+                                            GTK_WINDOW (self));
+
+              /* New device will be set at return from ppd selection */
+              gtk_widget_show (GTK_WIDGET (self->ppd_selection_dialog));
+            }
+          else
+            {
+              self->new_device = pp_print_device_copy (device);
+              self->user_callback (GTK_DIALOG (self), GTK_RESPONSE_OK, self->user_data);
+            }
+        }
+    }
+  else
+    {
+      self->user_callback (GTK_DIALOG (self), GTK_RESPONSE_CANCEL, self->user_data);
+    }
+}
+
+PpNewPrinterDialog *
+pp_new_printer_dialog_new (PPDList              *ppd_list,
+                           UserResponseCallback  user_callback,
+                           gpointer              user_data)
+{
+  PpNewPrinterDialog *self;
+
+  self = g_object_new (pp_new_printer_dialog_get_type (), NULL);
+
+  self->user_callback = user_callback;
+  self->user_data = user_data;
+
+  self->list = ppd_list_copy (ppd_list);
+
+  self->local_cups_devices = g_ptr_array_new_with_free_func (g_object_unref);
+
+  /* GCancellable for cancelling of async operations */
+  self->cancellable = g_cancellable_new ();
+
+  g_signal_connect_object (self, "response", G_CALLBACK (new_printer_dialog_response_cb), self, G_CONNECT_SWAPPED);
+
+  g_signal_connect_object (self->search_entry, "activate", G_CALLBACK (search_entry_activated_cb), self, G_CONNECT_SWAPPED);
+  g_signal_connect_object (self->search_entry, "search-changed", G_CALLBACK (search_entry_changed_cb), self, G_CONNECT_SWAPPED);
+
+  g_signal_connect_object (self->unlock_button, "clicked", G_CALLBACK (authenticate_samba_server), self, G_CONNECT_SWAPPED);
+
+  /* Authentication form widgets */
+  g_signal_connect_object (self->username_entry, "changed", G_CALLBACK (auth_entries_changed), self, G_CONNECT_SWAPPED);
+  g_signal_connect_object (self->password_entry, "changed", G_CALLBACK (auth_entries_changed), self, G_CONNECT_SWAPPED);
+  g_signal_connect_object (self->go_back_button, "clicked", G_CALLBACK (on_go_back_button_clicked), self, G_CONNECT_SWAPPED);
+
+  /* Set titlebar */
+  gtk_window_set_titlebar(GTK_WINDOW (self), GTK_WIDGET (self->headerbar));
+
+  /* Fill with data */
+  populate_devices_list (self);
+
+  return self;
+}
+
+static void
+pp_new_printer_dialog_dispose (GObject *object)
+{
+  PpNewPrinterDialog *self = PP_NEW_PRINTER_DIALOG (object);
+
+  g_cancellable_cancel (self->remote_host_cancellable);
+  g_cancellable_cancel (self->cancellable);
+
+  g_clear_handle_id (&self->host_search_timeout_id, g_source_remove);
+  g_clear_object (&self->remote_host_cancellable);
+  g_clear_object (&self->cancellable);
+  g_clear_pointer (&self->list, ppd_list_free);
+  g_clear_pointer (&self->local_cups_devices, g_ptr_array_unref);
+  g_clear_object (&self->new_device);
+  g_clear_object (&self->local_printer_icon);
+  g_clear_object (&self->remote_printer_icon);
+  g_clear_object (&self->authenticated_server_icon);
+  g_clear_object (&self->snmp_host);
+  g_clear_object (&self->socket_host);
+  g_clear_object (&self->lpd_host);
+  g_clear_object (&self->remote_cups_host);
+  g_clear_object (&self->samba_host);
+
+  if (self->ppd_selection_dialog != NULL)
+    {
+      gtk_window_destroy (GTK_WINDOW (self->ppd_selection_dialog));
+      self->ppd_selection_dialog = NULL;
+    }
+
+  if (self->num_of_dests > 0)
+    {
+      cupsFreeDests (self->num_of_dests, self->dests);
+      self->num_of_dests = 0;
+      self->dests = NULL;
+    }
+
+  G_OBJECT_CLASS (pp_new_printer_dialog_parent_class)->dispose (object);
+}
+
+void
+pp_new_printer_dialog_class_init (PpNewPrinterDialogClass *klass)
+{
+  GtkWidgetClass *widget_class = GTK_WIDGET_CLASS (klass);
+  GObjectClass   *object_class = G_OBJECT_CLASS (klass);
+
+  g_type_ensure (PP_TYPE_PRINT_DEVICE);
+
+  gtk_widget_class_set_template_from_resource (widget_class, "/org/gnome/control-center/printers/new-printer-dialog.ui");
+
+  gtk_widget_class_bind_template_child (widget_class, PpNewPrinterDialog, devices_liststore);
+  gtk_widget_class_bind_template_child (widget_class, PpNewPrinterDialog, devices_model_filter);
+
+  /* headerbar */
+  gtk_widget_class_bind_template_child (widget_class, PpNewPrinterDialog, headerbar);
+  gtk_widget_class_bind_template_child (widget_class, PpNewPrinterDialog, header_title);
+
+  /* headerbar topleft buttons */
+  gtk_widget_class_bind_template_child (widget_class, PpNewPrinterDialog, headerbar_topleft_buttons);
+  gtk_widget_class_bind_template_child (widget_class, PpNewPrinterDialog, go_back_button);
+
+  /* headerbar topright buttons */
+  gtk_widget_class_bind_template_child (widget_class, PpNewPrinterDialog, headerbar_topright_buttons);
+  gtk_widget_class_bind_template_child (widget_class, PpNewPrinterDialog, new_printer_add_button);
+  gtk_widget_class_bind_template_child (widget_class, PpNewPrinterDialog, unlock_button);
+  gtk_widget_class_bind_template_child (widget_class, PpNewPrinterDialog, authenticate_button);
+
+  /* dialogstack */
+  gtk_widget_class_bind_template_child (widget_class, PpNewPrinterDialog, dialog_stack);
+  gtk_widget_class_bind_template_child (widget_class, PpNewPrinterDialog, stack);
+
+  /* scrolledwindow1 */
+  gtk_widget_class_bind_template_child (widget_class, PpNewPrinterDialog, scrolledwindow1);
+  gtk_widget_class_bind_template_child (widget_class, PpNewPrinterDialog, devices_treeview);
+
+  gtk_widget_class_bind_template_child (widget_class, PpNewPrinterDialog, search_entry);
+
+  /* authentication page */
+  gtk_widget_class_bind_template_child (widget_class, PpNewPrinterDialog, authentication_title);
+  gtk_widget_class_bind_template_child (widget_class, PpNewPrinterDialog, authentication_text);
+  gtk_widget_class_bind_template_child (widget_class, PpNewPrinterDialog, username_entry);
+  gtk_widget_class_bind_template_child (widget_class, PpNewPrinterDialog, password_entry);
+
+  object_class->dispose = pp_new_printer_dialog_dispose;
+}
+
+
+void
+pp_new_printer_dialog_init (PpNewPrinterDialog *self)
+{
+  gtk_widget_init_template (GTK_WIDGET (self));
+}
+
+void
+pp_new_printer_dialog_set_ppd_list (PpNewPrinterDialog *self,
+                                    PPDList            *list)
+{
+  self->list = ppd_list_copy (list);
+
+  if (self->ppd_selection_dialog)
+    pp_ppd_selection_dialog_set_ppd_list (self->ppd_selection_dialog, self->list);
+}
+
+PpNewPrinter *
+pp_new_printer_dialog_get_new_printer (PpNewPrinterDialog *self)
+{
+  PpNewPrinter *new_printer = NULL;
+
+  new_printer = pp_new_printer_new ();
+  g_object_set (new_printer,
+                "name", pp_print_device_get_device_name (self->new_device),
+                "original-name", pp_print_device_get_device_original_name (self->new_device),
+                "device-uri", pp_print_device_get_device_uri (self->new_device),
+                "device-id", pp_print_device_get_device_id (self->new_device),
+                "ppd-name", pp_print_device_get_device_ppd (self->new_device),
+                "ppd-file-name", pp_print_device_get_device_ppd (self->new_device),
+                "info", pp_print_device_get_device_info (self->new_device),
+                "location", pp_print_device_get_device_location (self->new_device),
+                "make-and-model", pp_print_device_get_device_make_and_model (self->new_device),
+                "host-name", pp_print_device_get_host_name (self->new_device),
+                "host-port", pp_print_device_get_host_port (self->new_device),
+                "is-network-device", pp_print_device_is_network_device (self->new_device),
+                "window-id", 0,
+                NULL);
+
+  return new_printer;
+}
diff --git a/panels/printers/pp-new-printer-dialog.h b/panels/printers/pp-new-printer-dialog.h
new file mode 100644
index 0000000..78ac68d
--- /dev/null
+++ b/panels/printers/pp-new-printer-dialog.h
@@ -0,0 +1,38 @@
+/* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 8 -*-
+ *
+ * Copyright 2009-2010  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 2 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, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#pragma once
+
+#include <gtk/gtk.h>
+#include "pp-new-printer.h"
+#include "pp-utils.h"
+
+G_BEGIN_DECLS
+
+#define PP_TYPE_NEW_PRINTER_DIALOG (pp_new_printer_dialog_get_type ())
+G_DECLARE_FINAL_TYPE (PpNewPrinterDialog, pp_new_printer_dialog, PP, NEW_PRINTER_DIALOG, GtkDialog)
+
+PpNewPrinterDialog *pp_new_printer_dialog_new                  (PPDList              *ppd_list,
+                                                                UserResponseCallback  user_callback,
+                                                                gpointer              user_data);
+void                pp_new_printer_dialog_set_ppd_list         (PpNewPrinterDialog *dialog,
+                                                                PPDList            *list);
+PpNewPrinter       *pp_new_printer_dialog_get_new_printer (PpNewPrinterDialog *dialog);
+
+G_END_DECLS
diff --git a/panels/printers/pp-new-printer.c b/panels/printers/pp-new-printer.c
new file mode 100644
index 0000000..072a760
--- /dev/null
+++ b/panels/printers/pp-new-printer.c
@@ -0,0 +1,1300 @@
+/* -*- 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 2 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, see <http://www.gnu.org/licenses/>.
+ *
+ * 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 _PpNewPrinter
+{
+  GObject   parent_instance;
+
+  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;
+
+  GTask        *task;
+  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)
+{
+  PpNewPrinter *self = PP_NEW_PRINTER (object);
+
+  if (self->unlink_ppd_file && self->ppd_file_name)
+    g_unlink (self->ppd_file_name);
+
+  g_clear_pointer (&self->name, g_free);
+  g_clear_pointer (&self->original_name, g_free);
+  g_clear_pointer (&self->device_uri, g_free);
+  g_clear_pointer (&self->device_id, g_free);
+  g_clear_pointer (&self->ppd_name, g_free);
+  g_clear_pointer (&self->ppd_file_name, g_free);
+  g_clear_pointer (&self->info, g_free);
+  g_clear_pointer (&self->location, g_free);
+  g_clear_pointer (&self->make_and_model, g_free);
+  g_clear_pointer (&self->host_name, g_free);
+  g_clear_object (&self->task);
+  g_clear_object (&self->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 = PP_NEW_PRINTER (object);
+
+  switch (prop_id)
+    {
+      case PROP_NAME:
+        g_value_set_string (value, self->name);
+        break;
+      case PROP_ORIGINAL_NAME:
+        g_value_set_string (value, self->original_name);
+        break;
+      case PROP_DEVICE_URI:
+        g_value_set_string (value, self->device_uri);
+        break;
+      case PROP_DEVICE_ID:
+        g_value_set_string (value, self->device_id);
+        break;
+      case PROP_PPD_NAME:
+        g_value_set_string (value, self->ppd_name);
+        break;
+      case PROP_PPD_FILE_NAME:
+        g_value_set_string (value, self->ppd_file_name);
+        break;
+      case PROP_INFO:
+        g_value_set_string (value, self->info);
+        break;
+      case PROP_LOCATION:
+        g_value_set_string (value, self->location);
+        break;
+      case PROP_MAKE_AND_MODEL:
+        g_value_set_string (value, self->make_and_model);
+        break;
+      case PROP_HOST_NAME:
+        g_value_set_string (value, self->host_name);
+        break;
+      case PROP_HOST_PORT:
+        g_value_set_int (value, self->host_port);
+        break;
+      case PROP_IS_NETWORK_DEVICE:
+        g_value_set_boolean (value, self->is_network_device);
+        break;
+      case PROP_WINDOW_ID:
+        g_value_set_uint (value, self->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->name);
+        self->name = g_value_dup_string (value);
+        break;
+      case PROP_ORIGINAL_NAME:
+        g_free (self->original_name);
+        self->original_name = g_value_dup_string (value);
+        break;
+      case PROP_DEVICE_URI:
+        g_free (self->device_uri);
+        self->device_uri = g_value_dup_string (value);
+        break;
+      case PROP_DEVICE_ID:
+        g_free (self->device_id);
+        self->device_id = g_value_dup_string (value);
+        break;
+      case PROP_PPD_NAME:
+        g_free (self->ppd_name);
+        self->ppd_name = g_value_dup_string (value);
+        break;
+      case PROP_PPD_FILE_NAME:
+        g_free (self->ppd_file_name);
+        self->ppd_file_name = g_value_dup_string (value);
+        break;
+      case PROP_INFO:
+        g_free (self->info);
+        self->info = g_value_dup_string (value);
+        break;
+      case PROP_LOCATION:
+        g_free (self->location);
+        self->location = g_value_dup_string (value);
+        break;
+      case PROP_MAKE_AND_MODEL:
+        g_free (self->make_and_model);
+        self->make_and_model = g_value_dup_string (value);
+        break;
+      case PROP_HOST_NAME:
+        g_free (self->host_name);
+        self->host_name = g_value_dup_string (value);
+        break;
+      case PROP_HOST_PORT:
+        self->host_port = g_value_get_int (value);
+        break;
+      case PROP_IS_NETWORK_DEVICE:
+        self->is_network_device = g_value_get_boolean (value);
+        break;
+      case PROP_WINDOW_ID:
+        self->window_id = g_value_get_uint (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);
+
+  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_uint ("window-id",
+                       "WindowID",
+                       "Window ID of parent window",
+                       0, G_MAXUINT, 0,
+                       G_PARAM_READWRITE));
+}
+
+static void
+pp_new_printer_init (PpNewPrinter *self)
+{
+}
+
+PpNewPrinter *
+pp_new_printer_new ()
+{
+  return g_object_new (PP_TYPE_NEW_PRINTER, NULL);
+}
+
+static void printer_configure_async (PpNewPrinter *self);
+
+static void
+_pp_new_printer_add_async_cb (gboolean      success,
+                              PpNewPrinter *self)
+{
+  if (!success)
+    {
+      g_task_return_new_error (self->task,
+                               G_IO_ERROR,
+                               G_IO_ERROR_FAILED,
+                               "Installation of the new printer failed.");
+      return;
+    }
+
+  g_task_return_boolean (self->task, success);
+}
+
+static void
+printer_add_real_async_cb (cups_dest_t *destination,
+                           gpointer     user_data)
+{
+  PpNewPrinter        *self = user_data;
+  gboolean             success = FALSE;
+
+  if (destination)
+    {
+      success = TRUE;
+      cupsFreeDests (1, destination);
+    }
+
+  if (success)
+    {
+      printer_configure_async (self);
+    }
+  else
+    {
+      _pp_new_printer_add_async_cb (FALSE, self);
+    }
+}
+
+static void
+printer_add_real_async_dbus_cb (GObject      *source_object,
+                                GAsyncResult *res,
+                                gpointer      user_data)
+{
+  PpNewPrinter        *self = user_data;
+  g_autoptr(GVariant)  output = NULL;
+  g_autoptr(GError)    error = NULL;
+
+  output = g_dbus_connection_call_finish (G_DBUS_CONNECTION (source_object),
+                                          res,
+                                          &error);
+
+  if (output)
+    {
+      const gchar *ret_error;
+
+      g_variant_get (output, "(&s)", &ret_error);
+      if (ret_error[0] != '\0')
+        {
+          g_warning ("cups-pk-helper: addition of printer %s failed: %s", self->name, ret_error);
+        }
+    }
+  else
+    {
+      if (!g_error_matches (error, G_IO_ERROR, G_IO_ERROR_CANCELLED))
+        g_warning ("%s", error->message);
+    }
+
+  if (!g_error_matches (error, G_IO_ERROR, G_IO_ERROR_CANCELLED))
+    {
+      get_named_dest_async (self->name,
+                            printer_add_real_async_cb,
+                            self);
+    }
+}
+
+static void
+printer_add_real_async (PpNewPrinter *self)
+{
+  g_autoptr(GDBusConnection) bus = NULL;
+  g_autoptr(GError) error = NULL;
+
+  if (!self->ppd_name && !self->ppd_file_name)
+    {
+      _pp_new_printer_add_async_cb (FALSE, self);
+      return;
+    }
+
+  bus = g_bus_get_sync (G_BUS_TYPE_SYSTEM, NULL, &error);
+  if (!bus)
+    {
+      g_warning ("Failed to get system bus: %s", error->message);
+      _pp_new_printer_add_async_cb (FALSE, self);
+      return;
+    }
+
+  g_dbus_connection_call (bus,
+                          MECHANISM_BUS,
+                          "/",
+                          MECHANISM_BUS,
+                          self->ppd_name ? "PrinterAdd" : "PrinterAddWithPpdFile",
+                          g_variant_new ("(sssss)",
+                                         self->name,
+                                         self->device_uri,
+                                         self->ppd_name ? self->ppd_name : self->ppd_file_name,
+                                         self->info ? self->info : "",
+                                         self->location ? self->location : ""),
+                          G_VARIANT_TYPE ("(s)"),
+                          G_DBUS_CALL_FLAGS_NONE,
+                          DBUS_TIMEOUT,
+                          NULL,
+                          printer_add_real_async_dbus_cb,
+                          self);
+}
+
+static PPDName *
+get_ppd_item_from_output (GVariant *output)
+{
+  g_autoptr(GVariant) array = NULL;
+  gint      j;
+  static const char * const match_levels[] = {
+             "exact-cmd",
+             "exact",
+             "close",
+             "generic",
+             "none"};
+
+  if (output == NULL)
+    return NULL;
+
+  g_variant_get (output, "(@a(ss))", &array);
+  for (j = 0; j < G_N_ELEMENTS (match_levels); j++)
+    {
+      g_autoptr(GVariantIter) iter = NULL;
+      const gchar *driver, *match;
+
+      g_variant_get (array, "a(ss)", &iter);
+      while (g_variant_iter_next (iter, "(&s&s)", &driver, &match))
+        {
+          PPDName *ppd_item;
+
+          if (!g_str_equal (match, match_levels[j]))
+            continue;
+
+          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;
+
+          return ppd_item;
+        }
+    }
+
+  return NULL;
+}
+
+
+static void
+printer_add_async_scb3 (GObject      *source_object,
+                        GAsyncResult *res,
+                        gpointer      user_data)
+{
+  PpNewPrinter        *self = user_data;
+  g_autoptr(GVariant)  output = NULL;
+  PPDName             *ppd_item = NULL;
+  g_autoptr(GError)    error = NULL;
+
+  output = g_dbus_connection_call_finish (G_DBUS_CONNECTION (source_object),
+                                          res,
+                                          &error);
+
+  if (output)
+    {
+      ppd_item = get_ppd_item_from_output (output);
+    }
+  else
+    {
+      if (!g_error_matches (error, G_IO_ERROR, G_IO_ERROR_CANCELLED))
+        g_warning ("%s", error->message);
+    }
+
+  if (!g_error_matches (error, G_IO_ERROR, G_IO_ERROR_CANCELLED) &&
+      ppd_item && ppd_item->ppd_name)
+    {
+      self->ppd_name = g_strdup (ppd_item->ppd_name);
+      printer_add_real_async (self);
+    }
+  else
+    {
+      _pp_new_printer_add_async_cb (FALSE, self);
+    }
+
+  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)
+{
+  PpNewPrinter        *self = user_data;
+  g_autoptr(GVariant)  output = NULL;
+  g_autoptr(GError)    error = NULL;
+
+  output = g_dbus_connection_call_finish (G_DBUS_CONNECTION (source_object),
+                                          res,
+                                          &error);
+
+  if (output == NULL)
+    {
+      if (!g_error_matches (error, G_IO_ERROR, G_IO_ERROR_CANCELLED))
+        g_warning ("%s", error->message);
+    }
+
+  if (!g_error_matches (error, G_IO_ERROR, G_IO_ERROR_CANCELLED))
+    {
+      g_autoptr(GDBusConnection) bus = NULL;
+      g_autoptr(GError) bus_error = NULL;
+
+      /* Try whether CUPS has a driver for the new printer */
+      bus = g_bus_get_sync (G_BUS_TYPE_SESSION, NULL, &bus_error);
+      if (bus)
+        {
+          g_dbus_connection_call (bus,
+                                  SCP_BUS,
+                                  SCP_PATH,
+                                  SCP_IFACE,
+                                  "GetBestDrivers",
+                                  g_variant_new ("(sss)",
+                                                 self->device_id,
+                                                 self->make_and_model ? self->make_and_model : "",
+                                                 self->device_uri ? self->device_uri : ""),
+                                  G_VARIANT_TYPE ("(a(ss))"),
+                                  G_DBUS_CALL_FLAGS_NONE,
+                                  DBUS_TIMEOUT_LONG,
+                                  self->cancellable,
+                                  printer_add_async_scb3,
+                                  self);
+        }
+      else
+        {
+          g_warning ("Failed to get system bus: %s", bus_error->message);
+          _pp_new_printer_add_async_cb (FALSE, self);
+        }
+    }
+}
+
+static void
+printer_add_async_scb (GObject      *source_object,
+                       GAsyncResult *res,
+                       gpointer      user_data)
+{
+  PpNewPrinter        *self = user_data;
+  g_autoptr(GDBusConnection) bus = NULL;
+  GVariantBuilder      array_builder;
+  g_autoptr(GVariant)  output = NULL;
+  gboolean             cancelled = FALSE;
+  PPDName             *ppd_item = NULL;
+  g_autoptr(GError)    error = NULL;
+
+  output = g_dbus_connection_call_finish (G_DBUS_CONNECTION (source_object),
+                                          res,
+                                          &error);
+
+  if (output)
+    {
+      ppd_item = get_ppd_item_from_output (output);
+    }
+  else
+    {
+      cancelled = g_error_matches (error, G_IO_ERROR, G_IO_ERROR_CANCELLED);
+
+      if (!cancelled)
+        g_warning ("%s", error->message);
+    }
+
+  if (!cancelled)
+    {
+      if (ppd_item == NULL || ppd_item->ppd_match_level < PPD_EXACT_MATCH)
+        {
+	  g_autoptr(GError) bus_error = NULL;
+
+          bus = g_bus_get_sync (G_BUS_TYPE_SESSION, NULL, &bus_error);
+          if (bus)
+            {
+              g_variant_builder_init (&array_builder, G_VARIANT_TYPE ("as"));
+              g_variant_builder_add (&array_builder, "s", self->device_id);
+
+              g_dbus_connection_call (bus,
+                                      PACKAGE_KIT_BUS,
+                                      PACKAGE_KIT_PATH,
+                                      PACKAGE_KIT_MODIFY_IFACE,
+                                      "InstallPrinterDrivers",
+                                      g_variant_new ("(uass)",
+                                                     self->window_id,
+                                                     &array_builder,
+                                                     "hide-finished"),
+                                      G_VARIANT_TYPE ("()"),
+                                      G_DBUS_CALL_FLAGS_NONE,
+                                      DBUS_TIMEOUT_LONG,
+                                      NULL,
+                                      install_printer_drivers_cb,
+                                      self);
+            }
+          else
+            {
+              g_warning ("Failed to get session bus: %s", bus_error->message);
+              _pp_new_printer_add_async_cb (FALSE, self);
+            }
+        }
+      else if (ppd_item && ppd_item->ppd_name)
+        {
+          self->ppd_name = g_strdup (ppd_item->ppd_name);
+          printer_add_real_async (self);
+        }
+      else
+        {
+          _pp_new_printer_add_async_cb (FALSE, self);
+        }
+    }
+
+  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 *self = user_data;
+
+  self->ppd_file_name = g_strdup (ppd_filename);
+  if (self->ppd_file_name)
+    {
+      self->unlink_ppd_file = TRUE;
+      printer_add_real_async (self);
+    }
+  else
+    {
+      _pp_new_printer_add_async_cb (FALSE, self);
+    }
+}
+
+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)
+{
+  PpNewPrinter *self = data->new_printer;
+
+  if (data->set_accept_jobs_finished &&
+      data->set_enabled_finished &&
+      (data->autoconfigure_finished || self->is_network_device) &&
+      data->set_media_size_finished &&
+      data->install_missing_executables_finished)
+    {
+      _pp_new_printer_add_async_cb (TRUE, data->new_printer);
+
+      g_clear_object (&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)
+{
+  g_autoptr(GVariant) output = NULL;
+  PCData             *data = (PCData *) user_data;
+  g_autoptr(GError)   error = NULL;
+
+  output = g_dbus_connection_call_finish (G_DBUS_CONNECTION (source_object),
+                                          res,
+                                          &error);
+
+  if (output == NULL)
+    {
+      if (!g_error_matches (error, G_IO_ERROR, G_IO_ERROR_CANCELLED))
+        g_warning ("%s", error->message);
+    }
+
+  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)
+{
+  g_autoptr(GVariant) output = NULL;
+  PCData             *data = (PCData *) user_data;
+  g_autoptr(GError)   error = NULL;
+
+  output = g_dbus_connection_call_finish (G_DBUS_CONNECTION (source_object),
+                                          res,
+                                          &error);
+
+  if (output == NULL)
+    {
+      if (!g_error_matches (error, G_IO_ERROR, G_IO_ERROR_CANCELLED))
+        g_warning ("%s", error->message);
+    }
+
+  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)
+{
+  g_autoptr(GVariant) output = NULL;
+  IMEData            *data = (IMEData *) user_data;
+  g_autoptr(GError)   error = NULL;
+
+  output = g_dbus_connection_call_finish (G_DBUS_CONNECTION (source_object),
+                                          res,
+                                          &error);
+
+  if (output == NULL)
+    {
+      if (!g_error_matches (error, G_IO_ERROR, G_IO_ERROR_CANCELLED))
+        g_warning ("%s", error->message);
+    }
+
+  install_missing_executables_cb (data);
+}
+
+
+static void
+search_files_cb (GObject      *source_object,
+                 GAsyncResult *res,
+                 gpointer      user_data)
+{
+  g_autoptr(GVariant) output = NULL;
+  IMEData            *data = (IMEData *) user_data;
+  g_autoptr(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));
+    }
+  else
+    {
+      if (!g_error_matches (error, G_IO_ERROR, G_IO_ERROR_CANCELLED))
+        g_warning ("%s", error->message);
+    }
+
+  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
+        {
+          install_missing_executables_cb (data);
+        }
+    }
+}
+
+static void
+get_missing_executables_cb (GObject      *source_object,
+                            GAsyncResult *res,
+                            gpointer      user_data)
+{
+  g_autoptr(GVariant) output = NULL;
+  IMEData            *data = (IMEData *) user_data;
+  g_autoptr(GError)   error = NULL;
+  GList              *executables = NULL;
+  GList              *item;
+
+  if (data->ppd_file_name)
+    {
+      g_unlink (data->ppd_file_name);
+      g_clear_pointer (&data->ppd_file_name, g_free);
+    }
+
+  output = g_dbus_connection_call_finish (G_DBUS_CONNECTION (source_object),
+                                          res,
+                                          &error);
+
+  if (output)
+    {
+      g_autoptr(GVariant) array = NULL;
+      g_autoptr(GVariantIter) iter = NULL;
+      const gchar *executable;
+
+      g_variant_get (output, "(@as)", &array);
+
+      g_variant_get (array, "as", &iter);
+      while (g_variant_iter_next (iter, "&s", &executable))
+        executables = g_list_append (executables, g_strdup (executable));
+    }
+  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.");
+    }
+  else
+    {
+      if (!g_error_matches (error, G_IO_ERROR, G_IO_ERROR_CANCELLED))
+        g_warning ("%s", error->message);
+    }
+
+  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 (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
+    {
+      install_missing_executables_cb (data);
+    }
+}
+
+static void
+printer_get_ppd_cb (const gchar *ppd_filename,
+                    gpointer     user_data)
+{
+  g_autoptr(GDBusConnection) bus = NULL;
+  IMEData          *data = (IMEData *) user_data;
+  g_autoptr(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);
+        }
+      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)
+{
+  g_autoptr(GError)     error = NULL;
+  PCData               *data;
+  gboolean              result;
+
+  result = pp_maintenance_command_execute_finish (PP_MAINTENANCE_COMMAND (source_object), res, &error);
+
+  if (result)
+    {
+      data = (PCData *) user_data;
+
+      data->autoconfigure_finished = TRUE;
+      printer_configure_async_finish (data);
+    }
+  else
+    {
+      if (!g_error_matches (error, G_IO_ERROR, G_IO_ERROR_CANCELLED))
+        {
+          data = (PCData *) user_data;
+
+          g_warning ("%s", error->message);
+
+          data->autoconfigure_finished = TRUE;
+          printer_configure_async_finish (data);
+        }
+    }
+}
+
+static void
+printer_configure_async (PpNewPrinter *self)
+{
+  g_autoptr(GDBusConnection) bus = NULL;
+  PCData               *data;
+  IMEData              *ime_data;
+  gchar               **values;
+  g_autoptr(GError)     error = NULL;
+
+  data = g_new0 (PCData, 1);
+  data->new_printer = self;
+  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 (self->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)",
+                                                 self->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)",
+                                                 self->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);
+          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 (!self->is_network_device)
+    {
+      g_autoptr(PpMaintenanceCommand) command = NULL;
+
+      command = pp_maintenance_command_new (self->name,
+                                            "autoconfigure",
+                                            NULL,
+      /* 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_page_size_from_locale ());
+
+  printer_add_option_async (self->name, "PageSize", values, FALSE, NULL, pao_cb, data);
+
+  g_strfreev (values);
+
+  /* Install missing executables for printer */
+  ime_data = g_new0 (IMEData, 1);
+  ime_data->window_id = self->window_id;
+  if (data->cancellable)
+    ime_data->cancellable = g_object_ref (data->cancellable);
+  ime_data->user_data = data;
+
+  printer_get_ppd_async (self->name,
+                         NULL,
+                         0,
+                         printer_get_ppd_cb,
+                         ime_data);
+}
+
+void
+pp_new_printer_add_async (PpNewPrinter        *self,
+                          GCancellable        *cancellable,
+                          GAsyncReadyCallback  callback,
+                          gpointer             user_data)
+{
+  g_autoptr(GTask) task = NULL;
+
+  self->task = g_task_new (self, cancellable, callback, user_data);
+  self->cancellable = g_object_ref (cancellable);
+
+  if (self->ppd_name || self->ppd_file_name)
+    {
+      /* We have everything we need */
+      printer_add_real_async (self);
+    }
+  else if (self->device_id)
+    {
+      g_autoptr(GDBusConnection) bus = NULL;
+      g_autoptr(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)",
+                                                 self->device_id,
+                                                 self->make_and_model ? self->make_and_model : "",
+                                                 self->device_uri ? self->device_uri : ""),
+                                  G_VARIANT_TYPE ("(a(ss))"),
+                                  G_DBUS_CALL_FLAGS_NONE,
+                                  DBUS_TIMEOUT_LONG,
+                                  cancellable,
+                                  printer_add_async_scb,
+                                  self);
+        }
+      else
+        {
+          g_warning ("Failed to get system bus: %s", error->message);
+          _pp_new_printer_add_async_cb (FALSE, self);
+        }
+    }
+  else if (self->original_name && self->host_name)
+    {
+      /* Try to get PPD from remote CUPS */
+      printer_get_ppd_async (self->original_name,
+                             self->host_name,
+                             self->host_port,
+                             printer_add_async_scb4,
+                             self);
+    }
+  else
+    {
+      _pp_new_printer_add_async_cb (FALSE, self);
+    }
+}
+
+gboolean
+pp_new_printer_add_finish (PpNewPrinter  *self,
+                           GAsyncResult  *res,
+                           GError       **error)
+{
+  g_return_val_if_fail (g_task_is_valid (res, self), FALSE);
+  g_return_val_if_fail (error == NULL || *error == NULL, FALSE);
+  return g_task_propagate_boolean (G_TASK (res), error);
+}
diff --git a/panels/printers/pp-new-printer.h b/panels/printers/pp-new-printer.h
new file mode 100644
index 0000000..207bac4
--- /dev/null
+++ b/panels/printers/pp-new-printer.h
@@ -0,0 +1,42 @@
+/* -*- 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 2 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, see <http://www.gnu.org/licenses/>.
+ *
+ * Author: Marek Kasik <mkasik@redhat.com>
+ */
+
+#pragma once
+
+#include <glib-object.h>
+#include <gio/gio.h>
+
+G_BEGIN_DECLS
+
+#define PP_TYPE_NEW_PRINTER (pp_new_printer_get_type ())
+G_DECLARE_FINAL_TYPE (PpNewPrinter, pp_new_printer, PP, NEW_PRINTER, GObject)
+
+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
diff --git a/panels/printers/pp-options-dialog.c b/panels/printers/pp-options-dialog.c
new file mode 100644
index 0000000..36e9bb2
--- /dev/null
+++ b/panels/printers/pp-options-dialog.c
@@ -0,0 +1,940 @@
+/* -*- 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 2 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, see <http://www.gnu.org/licenses/>.
+ *
+ * Author: Marek Kasik <mkasik@redhat.com>
+ */
+
+#include "config.h"
+
+#include <unistd.h>
+#include <stdlib.h>
+#include <sys/types.h>
+#include <sys/wait.h>
+
+#include <glib.h>
+#include <glib/gi18n.h>
+#include <glib/gstdio.h>
+#include <gtk/gtk.h>
+
+#include <cups/cups.h>
+#include <cups/ppd.h>
+
+#include "pp-options-dialog.h"
+#include "pp-maintenance-command.h"
+#include "pp-ppd-option-widget.h"
+#include "pp-ipp-option-widget.h"
+#include "pp-utils.h"
+#include "pp-printer.h"
+
+struct _PpOptionsDialog {
+  GtkDialog    parent_instance;
+
+  GtkTreeSelection *categories_selection;
+  GtkTreeView      *categories_treeview;
+  GtkBox           *main_box;
+  GtkNotebook      *notebook;
+  GtkSpinner       *spinner;
+  GtkStack         *stack;
+
+  gchar       *printer_name;
+
+  gchar       *ppd_filename;
+  gboolean     ppd_filename_set;
+
+  cups_dest_t *destination;
+  gboolean     destination_set;
+
+  GHashTable  *ipp_attributes;
+  gboolean     ipp_attributes_set;
+
+  gboolean sensitive;
+};
+
+G_DEFINE_TYPE (PpOptionsDialog, pp_options_dialog, GTK_TYPE_DIALOG)
+
+enum
+{
+  CATEGORY_IDS_COLUMN = 0,
+  CATEGORY_NAMES_COLUMN
+};
+
+/* These lists come from Gtk+ */
+/* TODO: Only "Resolution" currently has a context to disambiguate it from
+ *       the display settings. All of these should have contexts, but it
+ *       was late in the release cycle and this partial solution was
+ *       preferable. See:
+ *       https://gitlab.gnome.org/GNOME/gnome-control-center/merge_requests/414#note_446778
+ */
+static const struct {
+  const char *keyword;
+  const char *translation_context;
+  const char *translation;
+} ppd_option_translations[] = {
+  { "Duplex", NULL, N_("Two Sided") },
+  { "MediaType", NULL, N_("Paper Type") },
+  { "InputSlot", NULL, N_("Paper Source") },
+  { "OutputBin", NULL, N_("Output Tray") },
+  { "Resolution", "printing option", NC_("printing option", "Resolution") },
+  { "PreFilter", NULL, N_("GhostScript pre-filtering") },
+};
+
+/* keep sorted when changing */
+static const char *allowed_page_setup_options[] = {
+  "InputSlot",
+  "MediaType",
+  "OutputBin",
+  "PageSize",
+};
+
+/* keep sorted when changing */
+static const char *allowed_color_options[] = {
+  "BRColorEnhancement",
+  "BRColorMatching",
+  "BRColorMatching",
+  "BRColorMode",
+  "BRGammaValue",
+  "BRImprovedGray",
+  "BlackSubstitution",
+  "ColorModel",
+  "HPCMYKInks",
+  "HPCSGraphics",
+  "HPCSImages",
+  "HPCSText",
+  "HPColorSmart",
+  "RPSBlackMode",
+  "RPSBlackOverPrint",
+  "Rcmyksimulation",
+};
+
+/* keep sorted when changing */
+static const char *allowed_color_groups[] = {
+  "Color",
+  "Color1",
+  "Color2",
+  "ColorBalance",
+  "ColorPage",
+  "ColorSettings1",
+  "ColorSettings2",
+  "ColorSettings3",
+  "ColorSettings4",
+  "EPColorSettings",
+  "FPColorWise1",
+  "FPColorWise2",
+  "FPColorWise3",
+  "FPColorWise4",
+  "FPColorWise5",
+  "HPCMYKInksPanel",
+  "HPColorOptions",
+  "HPColorOptionsPanel",
+  "HPColorQualityOptionsPanel",
+  "ManualColor",
+};
+
+/* keep sorted when changing */
+static const char *allowed_image_quality_options[] = {
+  "BRDocument",
+  "BRHalfTonePattern",
+  "BRNormalPrt",
+  "BRPrintQuality",
+  "BitsPerPixel",
+  "Darkness",
+  "Dithering",
+  "EconoMode",
+  "Economode",
+  "HPEconoMode",
+  "HPEdgeControl",
+  "HPGraphicsHalftone",
+  "HPHalftone",
+  "HPImagingOptions",
+  "HPLJDensity",
+  "HPPhotoHalftone",
+  "HPPrintQualityOptions",
+  "HPResolutionOptions",
+  "OutputMode",
+  "REt",
+  "RPSBitsPerPixel",
+  "RPSDitherType",
+  "Resolution",
+  "ScreenLock",
+  "Smoothing",
+  "TonerSaveMode",
+  "UCRGCRForImage",
+};
+
+/* keep sorted when changing */
+static const char *allowed_image_quality_groups[] = {
+  "EPQualitySettings",
+  "FPImageQuality1",
+  "FPImageQuality2",
+  "FPImageQuality3",
+  "ImageQualityPage",
+  "Quality",
+};
+
+/* keep sorted when changing */
+static const char * allowed_finishing_options[] = {
+  "BindColor",
+  "BindEdge",
+  "BindType",
+  "BindWhen",
+  "Booklet",
+  "FoldType",
+  "FoldWhen",
+  "HPStaplerOptions",
+  "Jog",
+  "Slipsheet",
+  "Sorter",
+  "StapleLocation",
+  "StapleOrientation",
+  "StapleWhen",
+  "StapleX",
+  "StapleY",
+};
+
+/* keep sorted when changing */
+static const char *allowed_job_groups[] = {
+  "JobHandling",
+  "JobLog",
+};
+
+/* keep sorted when changing */
+static const char *allowed_finishing_groups[] = {
+  "Booklet",
+  "BookletCover",
+  "BookletModeOptions",
+  "FPFinishing1",
+  "FPFinishing2",
+  "FPFinishing3",
+  "FPFinishing4",
+  "Finishing",
+  "FinishingOptions",
+  "FinishingPage",
+  "HPBookletPanel",
+  "HPFinishing",
+  "HPFinishingOptions",
+  "HPFinishingPanel",
+};
+
+/* keep sorted when changing */
+static const char *allowed_installable_options_groups[] = {
+  "InstallableOptions",
+};
+
+/* keep sorted when changing */
+static const char *allowed_page_setup_groups[] = {
+  "HPMarginAndLayout",
+  "OutputControl",
+  "PaperHandling",
+  "Paper",
+  "Source",
+};
+
+/* keep sorted when changing */
+static const char *disallowed_ppd_options[] = {
+  "Collate",
+  "Copies",
+  "Duplex",
+  "HPManualDuplexOrientation",
+  "HPManualDuplexSwitch",
+  "OutputOrder",
+  "PageRegion"
+};
+
+static int
+strptr_cmp (const void *a,
+	    const void *b)
+{
+  char **aa = (char **)a;
+  char **bb = (char **)b;
+  return strcmp (*aa, *bb);
+}
+
+static gboolean
+string_in_table (gchar       *str,
+		 const gchar *table[],
+		 gint         table_len)
+{
+  return bsearch (&str, table, table_len, sizeof (char *), (void *)strptr_cmp) != NULL;
+}
+
+#define STRING_IN_TABLE(_str, _table) (string_in_table (_str, _table, G_N_ELEMENTS (_table)))
+
+static const gchar *
+ppd_option_name_translate (ppd_option_t *option)
+{
+  gint i;
+
+  for (i = 0; i < G_N_ELEMENTS (ppd_option_translations); i++)
+    {
+      if (g_strcmp0 (ppd_option_translations[i].keyword, option->keyword) == 0)
+        {
+          if (ppd_option_translations[i].translation_context)
+            return g_dpgettext2(NULL, ppd_option_translations[i].translation_context, ppd_option_translations[i].translation);
+          else
+            return _(ppd_option_translations[i].translation);
+        }
+    }
+
+  return option->text;
+}
+
+static gint
+grid_get_height (GtkWidget *grid)
+{
+  GtkWidget *child;
+  gint   height = 0;
+  gint   row = 0;
+  gint   max = 0;
+
+  for (child = gtk_widget_get_first_child (grid);
+       child;
+       child = gtk_widget_get_next_sibling (child))
+    {
+      gtk_grid_query_child (GTK_GRID (grid),
+                            child,
+                            NULL, &row,
+                            NULL, &height);
+
+      if (height + row > max)
+        max = height + row;
+    }
+
+  return max;
+}
+
+static gboolean
+grid_is_empty (GtkWidget *grid)
+{
+  return gtk_widget_get_first_child (grid) == NULL;
+}
+
+static GtkWidget *
+ipp_option_add (IPPAttribute *attr_supported,
+                IPPAttribute *attr_default,
+                const gchar  *option_name,
+                const gchar  *option_display_name,
+                const gchar  *printer_name,
+                GtkWidget    *grid,
+                gboolean      sensitive)
+{
+  GtkStyleContext *context;
+  GtkWidget       *widget;
+  GtkWidget       *label;
+  gint             position;
+
+  widget = (GtkWidget *) pp_ipp_option_widget_new (attr_supported,
+                                                   attr_default,
+                                                   option_name,
+                                                   printer_name);
+  if (widget)
+    {
+      gtk_widget_show (widget);
+      gtk_widget_set_sensitive (widget, sensitive);
+      position = grid_get_height (grid);
+
+      label = gtk_label_new (option_display_name);
+      gtk_widget_show (GTK_WIDGET (label));
+      gtk_label_set_mnemonic_widget (GTK_LABEL (label), widget);
+      context = gtk_widget_get_style_context (label);
+      gtk_style_context_add_class (context, "dim-label");
+      gtk_widget_set_halign (label, GTK_ALIGN_END);
+      gtk_widget_set_valign (label, GTK_ALIGN_CENTER);
+      gtk_widget_set_margin_start (label, 10);
+      gtk_grid_attach (GTK_GRID (grid), label, 0, position, 1, 1);
+
+      gtk_widget_set_margin_start (widget, 20);
+      gtk_grid_attach (GTK_GRID (grid), widget, 1, position, 1, 1);
+    }
+
+  return widget;
+}
+
+static GtkWidget *
+ppd_option_add (ppd_option_t  option,
+                const gchar  *printer_name,
+                GtkWidget    *grid,
+                gboolean      sensitive)
+{
+  GtkStyleContext *context;
+  GtkWidget       *widget;
+  GtkWidget       *label;
+  gint             position;
+
+  widget = (GtkWidget *) pp_ppd_option_widget_new (&option, printer_name);
+  if (widget)
+    {
+      gtk_widget_show (widget);
+      gtk_widget_set_sensitive (widget, sensitive);
+      position = grid_get_height (grid);
+
+      label = gtk_label_new (ppd_option_name_translate (&option));
+      gtk_label_set_mnemonic_widget (GTK_LABEL (label), widget);
+      context = gtk_widget_get_style_context (label);
+      gtk_style_context_add_class (context, "dim-label");
+      gtk_widget_set_halign (label, GTK_ALIGN_END);
+      gtk_widget_set_valign (label, GTK_ALIGN_CENTER);
+      gtk_widget_set_margin_start (label, 10);
+      gtk_grid_attach (GTK_GRID (grid), label, 0, position, 1, 1);
+
+      gtk_widget_set_margin_start (widget, 20);
+      gtk_grid_attach (GTK_GRID (grid), widget, 1, position, 1, 1);
+    }
+
+  return widget;
+}
+
+static GtkWidget *
+tab_grid_new ()
+{
+  GtkWidget *grid;
+
+  grid = gtk_grid_new ();
+  gtk_widget_set_margin_start (grid, 20);
+  gtk_widget_set_margin_end (grid, 20);
+  gtk_widget_set_margin_top (grid, 20);
+  gtk_widget_set_margin_bottom (grid, 20);
+  gtk_grid_set_row_spacing (GTK_GRID (grid), 15);
+
+  return grid;
+}
+
+static void
+tab_add (PpOptionsDialog *self,
+         const gchar     *tab_name,
+         GtkWidget       *grid)
+{
+  GtkListStore *store;
+  GtkTreeIter   iter;
+  GtkWidget    *scrolled_window;
+  gboolean      unref_store = FALSE;
+  gint          id;
+
+  if (!grid_is_empty (grid))
+    {
+      scrolled_window = gtk_scrolled_window_new ();
+      gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_window),
+                                      GTK_POLICY_NEVER,
+                                      GTK_POLICY_AUTOMATIC);
+      gtk_scrolled_window_set_child (GTK_SCROLLED_WINDOW (scrolled_window), grid);
+
+      id = gtk_notebook_append_page (self->notebook,
+                                     scrolled_window,
+                                     NULL);
+
+      if (id >= 0)
+        {
+          store = GTK_LIST_STORE (gtk_tree_view_get_model (self->categories_treeview));
+          if (!store)
+            {
+              store = gtk_list_store_new (2, G_TYPE_INT, G_TYPE_STRING);
+              unref_store = TRUE;
+            }
+
+          gtk_list_store_append (store, &iter);
+          gtk_list_store_set (store, &iter,
+                              CATEGORY_IDS_COLUMN, id,
+                              CATEGORY_NAMES_COLUMN, tab_name,
+                              -1);
+
+          if (unref_store)
+            {
+              gtk_tree_view_set_model (self->categories_treeview, GTK_TREE_MODEL (store));
+              g_object_unref (store);
+            }
+        }
+    }
+  else
+    {
+      g_object_ref_sink (grid);
+      g_object_unref (grid);
+    }
+}
+
+static void
+category_selection_changed_cb (PpOptionsDialog *self)
+{
+  GtkTreeModel *model;
+  GtkTreeIter   iter;
+  gint          id = -1;
+
+  if (gtk_tree_selection_get_selected (self->categories_selection, &model, &iter))
+    {
+      gtk_tree_model_get (model, &iter,
+			  CATEGORY_IDS_COLUMN, &id,
+			  -1);
+    }
+
+  if (id >= 0)
+    {
+      gtk_notebook_set_current_page (self->notebook, id);
+    }
+}
+
+static void
+populate_options_real (PpOptionsDialog *self)
+{
+  GtkTreeModel *model;
+  GtkTreeIter   iter;
+  ppd_file_t   *ppd_file;
+  GtkWidget    *grid;
+  GtkWidget    *general_tab_grid = tab_grid_new ();
+  GtkWidget    *page_setup_tab_grid = tab_grid_new ();
+  GtkWidget    *installable_options_tab_grid = tab_grid_new ();
+  GtkWidget    *job_tab_grid = tab_grid_new ();
+  GtkWidget    *image_quality_tab_grid = tab_grid_new ();
+  GtkWidget    *color_tab_grid = tab_grid_new ();
+  GtkWidget    *finishing_tab_grid = tab_grid_new ();
+  GtkWidget    *advanced_tab_grid = tab_grid_new ();
+  gint          i, j;
+
+  gtk_spinner_stop (self->spinner);
+
+  gtk_stack_set_visible_child (self->stack, GTK_WIDGET (self->main_box));
+
+  if (self->ipp_attributes)
+    {
+      /* Add number-up option to Page Setup tab */
+      ipp_option_add (g_hash_table_lookup (self->ipp_attributes,
+                                           "number-up-supported"),
+                      g_hash_table_lookup (self->ipp_attributes,
+                                           "number-up-default"),
+                      "number-up",
+                      /* Translators: This option sets number of pages printed on one sheet */
+                      _("Pages per side"),
+                      self->printer_name,
+                      page_setup_tab_grid,
+                      self->sensitive);
+
+      /* Add sides option to Page Setup tab */
+      ipp_option_add (g_hash_table_lookup (self->ipp_attributes,
+                                           "sides-supported"),
+                      g_hash_table_lookup (self->ipp_attributes,
+                                           "sides-default"),
+                      "sides",
+                      /* Translators: This option sets whether to print on both sides of paper */
+                      _("Two-sided"),
+                      self->printer_name,
+                      page_setup_tab_grid,
+                      self->sensitive);
+
+      /* Add orientation-requested option to Page Setup tab */
+      ipp_option_add (g_hash_table_lookup (self->ipp_attributes,
+                                           "orientation-requested-supported"),
+                      g_hash_table_lookup (self->ipp_attributes,
+                                           "orientation-requested-default"),
+                      "orientation-requested",
+                      /* Translators: This option sets orientation of print (portrait, landscape...) */
+                      _("Orientation"),
+                      self->printer_name,
+                      page_setup_tab_grid,
+                      self->sensitive);
+    }
+
+  if (self->destination && self->ppd_filename)
+    {
+      ppd_file = ppdOpenFile (self->ppd_filename);
+      ppdLocalize (ppd_file);
+
+      if (ppd_file)
+        {
+          ppdMarkDefaults (ppd_file);
+          cupsMarkOptions (ppd_file,
+                           self->destination->num_options,
+                           self->destination->options);
+
+          for (i = 0; i < ppd_file->num_groups; i++)
+            {
+              for (j = 0; j < ppd_file->groups[i].num_options; j++)
+                {
+                  grid = NULL;
+
+                  if (STRING_IN_TABLE (ppd_file->groups[i].name,
+                                       allowed_color_groups))
+                    grid = color_tab_grid;
+                  else if (STRING_IN_TABLE (ppd_file->groups[i].name,
+                                            allowed_image_quality_groups))
+                    grid = image_quality_tab_grid;
+                  else if (STRING_IN_TABLE (ppd_file->groups[i].name,
+                                            allowed_job_groups))
+                    grid = job_tab_grid;
+                  else if (STRING_IN_TABLE (ppd_file->groups[i].name,
+                                            allowed_finishing_groups))
+                    grid = finishing_tab_grid;
+                  else if (STRING_IN_TABLE (ppd_file->groups[i].name,
+                                            allowed_installable_options_groups))
+                    grid = installable_options_tab_grid;
+                  else if (STRING_IN_TABLE (ppd_file->groups[i].name,
+                                            allowed_page_setup_groups))
+                    grid = page_setup_tab_grid;
+
+                  if (!STRING_IN_TABLE (ppd_file->groups[i].options[j].keyword,
+                                        disallowed_ppd_options))
+                    {
+                      if (!grid && STRING_IN_TABLE (ppd_file->groups[i].options[j].keyword,
+                                                    allowed_color_options))
+                        grid = color_tab_grid;
+                      else if (!grid && STRING_IN_TABLE (ppd_file->groups[i].options[j].keyword,
+                                                         allowed_image_quality_options))
+                        grid = image_quality_tab_grid;
+                      else if (!grid && STRING_IN_TABLE (ppd_file->groups[i].options[j].keyword,
+                                                         allowed_finishing_options))
+                        grid = finishing_tab_grid;
+                      else if (!grid && STRING_IN_TABLE (ppd_file->groups[i].options[j].keyword,
+                                                         allowed_page_setup_options))
+                        grid = page_setup_tab_grid;
+
+                      if (!grid)
+                        grid = advanced_tab_grid;
+
+                      ppd_option_add (ppd_file->groups[i].options[j],
+                                      self->printer_name,
+                                      grid,
+                                      self->sensitive);
+                    }
+                }
+            }
+
+          ppdClose (ppd_file);
+        }
+    }
+
+  self->ppd_filename_set = FALSE;
+  if (self->ppd_filename)
+    {
+      g_unlink (self->ppd_filename);
+      g_free (self->ppd_filename);
+      self->ppd_filename = NULL;
+    }
+
+  self->destination_set = FALSE;
+  if (self->destination)
+    {
+      cupsFreeDests (1, self->destination);
+      self->destination = NULL;
+    }
+
+  self->ipp_attributes_set = FALSE;
+  if (self->ipp_attributes)
+    {
+      g_hash_table_unref (self->ipp_attributes);
+      self->ipp_attributes = NULL;
+    }
+
+  /* Translators: "General" tab contains general printer options */
+  tab_add (self, C_("Printer Option Group", "General"), general_tab_grid);
+
+  /* Translators: "Page Setup" tab contains settings related to pages (page size, paper source, etc.) */
+  tab_add (self, C_("Printer Option Group", "Page Setup"), page_setup_tab_grid);
+
+  /* Translators: "Installable Options" tab contains settings of presence of installed options (amount of RAM, duplex unit, etc.) */
+  tab_add (self, C_("Printer Option Group", "Installable Options"), installable_options_tab_grid);
+
+  /* Translators: "Job" tab contains settings for jobs */
+  tab_add (self, C_("Printer Option Group", "Job"), job_tab_grid);
+
+  /* Translators: "Image Quality" tab contains settings for quality of output print (e.g. resolution) */
+  tab_add (self, C_("Printer Option Group", "Image Quality"), image_quality_tab_grid);
+
+  /* Translators: "Color" tab contains color settings (e.g. color printing) */
+  tab_add (self, C_("Printer Option Group", "Color"), color_tab_grid);
+
+  /* Translators: "Finishing" tab contains finishing settings (e.g. booklet printing) */
+  tab_add (self, C_("Printer Option Group", "Finishing"), finishing_tab_grid);
+
+  /* Translators: "Advanced" tab contains all others settings */
+  tab_add (self, C_("Printer Option Group", "Advanced"), advanced_tab_grid);
+
+  /* Select the first option group */
+  if ((model = gtk_tree_view_get_model (self->categories_treeview)) != NULL &&
+      gtk_tree_model_get_iter_first (model, &iter))
+    gtk_tree_selection_select_iter (self->categories_selection, &iter);
+}
+
+static void
+printer_get_ppd_cb (const gchar *ppd_filename,
+                    gpointer     user_data)
+{
+  PpOptionsDialog *self = (PpOptionsDialog *) user_data;
+
+  if (self->ppd_filename)
+    {
+      g_unlink (self->ppd_filename);
+      g_free (self->ppd_filename);
+    }
+
+  self->ppd_filename = g_strdup (ppd_filename);
+  self->ppd_filename_set = TRUE;
+
+  if (self->destination_set &&
+      self->ipp_attributes_set)
+    {
+      populate_options_real (self);
+    }
+}
+
+static void
+get_named_dest_cb (cups_dest_t *dest,
+                   gpointer     user_data)
+{
+  PpOptionsDialog *self = (PpOptionsDialog *) user_data;
+
+  if (self->destination)
+    cupsFreeDests (1, self->destination);
+
+  self->destination = dest;
+  self->destination_set = TRUE;
+
+  if (self->ppd_filename_set &&
+      self->ipp_attributes_set)
+    {
+      populate_options_real (self);
+    }
+}
+
+static void
+get_ipp_attributes_cb (GHashTable *table,
+                       gpointer    user_data)
+{
+  PpOptionsDialog *self = (PpOptionsDialog *) user_data;
+
+  if (self->ipp_attributes)
+    g_hash_table_unref (self->ipp_attributes);
+
+  self->ipp_attributes = g_hash_table_ref (table);
+  self->ipp_attributes_set = TRUE;
+
+  if (self->ppd_filename_set &&
+      self->destination_set)
+    {
+      populate_options_real (self);
+    }
+}
+
+static void
+populate_options (PpOptionsDialog *self)
+{
+  GtkTreeViewColumn  *column;
+  GtkCellRenderer    *renderer;
+  /*
+   * Options which we need to obtain through an IPP request
+   * to be able to fill the options dialog.
+   * *-supported - possible values of the option
+   * *-default - actual value of the option
+   */
+  const gchar        *attributes[] =
+    { "number-up-supported",
+      "number-up-default",
+      "sides-supported",
+      "sides-default",
+      "orientation-requested-supported",
+      "orientation-requested-default",
+      NULL};
+
+  gtk_stack_set_visible_child (self->stack, GTK_WIDGET (self->spinner));
+
+  renderer = gtk_cell_renderer_text_new ();
+
+  column = gtk_tree_view_column_new_with_attributes ("Categories", renderer,
+                                                     "text", CATEGORY_NAMES_COLUMN, NULL);
+  gtk_tree_view_column_set_expand (column, TRUE);
+  gtk_tree_view_append_column (self->categories_treeview, column);
+
+  gtk_spinner_start (self->spinner);
+
+  printer_get_ppd_async (self->printer_name,
+                         NULL,
+                         0,
+                         printer_get_ppd_cb,
+                         self);
+
+  get_named_dest_async (self->printer_name,
+                        get_named_dest_cb,
+                        self);
+
+  get_ipp_attributes_async (self->printer_name,
+                            (gchar **) attributes,
+                            get_ipp_attributes_cb,
+                            self);
+}
+
+static void
+pp_maintenance_command_execute_cb (GObject      *source_object,
+                                   GAsyncResult *res,
+                                   gpointer      user_data)
+{
+  pp_maintenance_command_execute_finish (PP_MAINTENANCE_COMMAND(source_object), res, NULL);
+}
+
+static gchar *
+get_testprint_filename (const gchar *datadir)
+{
+  const gchar *testprint[] = { "/data/testprint",
+                               "/data/testprint.ps",
+                               NULL };
+  gchar       *filename = NULL;
+  gint         i;
+
+  for (i = 0; testprint[i] != NULL; i++)
+    {
+      filename = g_strconcat (datadir, testprint[i], NULL);
+      if (g_access (filename, R_OK) == 0)
+        break;
+
+      g_clear_pointer (&filename, g_free);
+    }
+
+  return filename;
+}
+
+static void
+print_test_page_cb (GObject      *source_object,
+                    GAsyncResult *result,
+                    gpointer      user_data)
+{
+  pp_printer_print_file_finish (PP_PRINTER (source_object),
+                                result, NULL);
+}
+
+static void
+test_page_cb (PpOptionsDialog *self)
+{
+  gint i;
+
+  if (self->printer_name)
+    {
+      const gchar      *const dirs[] = { "/usr/share/cups",
+                                         "/usr/local/share/cups",
+                                         NULL };
+      const gchar      *datadir = NULL;
+      g_autofree gchar *filename = NULL;
+
+      datadir = getenv ("CUPS_DATADIR");
+      if (datadir != NULL)
+        {
+          filename = get_testprint_filename (datadir);
+        }
+      else
+        {
+          for (i = 0; dirs[i] != NULL && filename == NULL; i++)
+            filename = get_testprint_filename (dirs[i]);
+        }
+
+      if (filename != NULL)
+        {
+          g_autoptr(PpPrinter) printer = NULL;
+
+          printer = pp_printer_new (self->printer_name);
+          pp_printer_print_file_async (printer,
+                                       filename,
+          /* Translators: Name of job which makes printer to print test page */
+                                       _("Test Page"),
+                                       NULL,
+                                       print_test_page_cb,
+                                       NULL);
+        }
+      else
+        {
+          g_autoptr(PpMaintenanceCommand) command = NULL;
+
+          command = pp_maintenance_command_new (self->printer_name,
+                                                "PrintSelfTestPage",
+                                                NULL,
+          /* Translators: Name of job which makes printer to print test page */
+                                                _("Test page"));
+
+          pp_maintenance_command_execute_async (command, NULL, pp_maintenance_command_execute_cb, NULL);
+        }
+    }
+}
+
+PpOptionsDialog *
+pp_options_dialog_new (gchar   *printer_name,
+                       gboolean sensitive)
+{
+  PpOptionsDialog *self;
+
+  self = g_object_new (pp_options_dialog_get_type (),
+                       "use-header-bar", 1,
+                       NULL);
+
+  self->printer_name = g_strdup (printer_name);
+
+  self->sensitive = sensitive;
+
+  gtk_window_set_title (GTK_WINDOW (self), printer_name);
+
+  populate_options (self);
+
+  return self;
+}
+
+static void
+pp_options_dialog_dispose (GObject *object)
+{
+  PpOptionsDialog *self = PP_OPTIONS_DIALOG (object);
+
+  g_free (self->printer_name);
+  self->printer_name = NULL;
+
+  if (self->ppd_filename)
+    {
+      g_unlink (self->ppd_filename);
+      g_free (self->ppd_filename);
+      self->ppd_filename = NULL;
+    }
+
+  if (self->destination)
+    {
+      cupsFreeDests (1, self->destination);
+      self->destination = NULL;
+    }
+
+  if (self->ipp_attributes)
+    {
+      g_hash_table_unref (self->ipp_attributes);
+      self->ipp_attributes = NULL;
+    }
+
+  G_OBJECT_CLASS (pp_options_dialog_parent_class)->dispose (object);
+}
+
+void
+pp_options_dialog_class_init (PpOptionsDialogClass *klass)
+{
+  GObjectClass *object_class = G_OBJECT_CLASS (klass);
+  GtkWidgetClass *widget_class = GTK_WIDGET_CLASS (klass);
+
+  object_class->dispose = pp_options_dialog_dispose;
+
+  gtk_widget_class_set_template_from_resource (widget_class, "/org/gnome/control-center/printers/pp-options-dialog.ui");
+
+  gtk_widget_class_bind_template_child (widget_class, PpOptionsDialog, categories_selection);
+  gtk_widget_class_bind_template_child (widget_class, PpOptionsDialog, categories_treeview);
+  gtk_widget_class_bind_template_child (widget_class, PpOptionsDialog, main_box);
+  gtk_widget_class_bind_template_child (widget_class, PpOptionsDialog, notebook);
+  gtk_widget_class_bind_template_child (widget_class, PpOptionsDialog, spinner);
+  gtk_widget_class_bind_template_child (widget_class, PpOptionsDialog, stack);
+
+  gtk_widget_class_bind_template_callback (widget_class, category_selection_changed_cb);
+  gtk_widget_class_bind_template_callback (widget_class, test_page_cb);
+}
+
+void
+pp_options_dialog_init (PpOptionsDialog *self)
+{
+  gtk_widget_init_template (GTK_WIDGET (self));
+}
diff --git a/panels/printers/pp-options-dialog.h b/panels/printers/pp-options-dialog.h
new file mode 100644
index 0000000..9c881eb
--- /dev/null
+++ b/panels/printers/pp-options-dialog.h
@@ -0,0 +1,34 @@
+/* -*- 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 2 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, see <http://www.gnu.org/licenses/>.
+ *
+ * Author: Marek Kasik <mkasik@redhat.com>
+ */
+
+#pragma once
+
+#include <gtk/gtk.h>
+#include "pp-utils.h"
+
+G_BEGIN_DECLS
+
+#define PP_TYPE_OPTIONS_DIALOG (pp_options_dialog_get_type ())
+G_DECLARE_FINAL_TYPE (PpOptionsDialog, pp_options_dialog, PP, OPTIONS_DIALOG, GtkDialog)
+
+PpOptionsDialog *pp_options_dialog_new (gchar   *printer_name,
+                                        gboolean sensitive);
+
+G_END_DECLS
diff --git a/panels/printers/pp-options-dialog.ui b/panels/printers/pp-options-dialog.ui
new file mode 100644
index 0000000..49e6fb9
--- /dev/null
+++ b/panels/printers/pp-options-dialog.ui
@@ -0,0 +1,75 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!-- Generated with glade 3.18.3 -->
+<interface>
+  <requires lib="gtk+" version="3.12"/>
+  <template class="PpOptionsDialog" parent="GtkDialog">
+    <property name="width_request">500</property>
+    <property name="height_request">400</property>
+    <property name="resizable">False</property>
+    <property name="modal">True</property>
+    <child internal-child="headerbar">
+      <object class="GtkHeaderBar">
+        <child>
+          <object class="GtkButton">
+            <property name="label" translatable="yes" comments="Translators: This button triggers the printing of a test page.">Test Page</property>
+            <signal name="clicked" handler="test_page_cb" object="PpOptionsDialog" swapped="yes"/>
+          </object>
+        </child>
+      </object>
+    </child>
+    <child>
+      <object class="GtkBox">
+        <child>
+          <object class="GtkStack" id="stack">
+            <property name="hhomogeneous">True</property>
+            <property name="vhomogeneous">True</property>
+            <child>
+              <object class="GtkBox" id="main_box">
+                <property name="orientation">vertical</property>
+                <property name="spacing">10</property>
+                <child>
+                  <object class="GtkBox">
+                    <property name="hexpand">True</property>
+                    <property name="vexpand">True</property>
+                    <child>
+                      <object class="GtkScrolledWindow">
+                        <property name="width_request">120</property>
+                        <property name="hscrollbar_policy">never</property>
+                        <child>
+                          <object class="GtkTreeView" id="categories_treeview">
+                            <property name="headers_visible">False</property>
+                            <child internal-child="selection">
+                              <object class="GtkTreeSelection" id="categories_selection">
+                                <signal name="changed" handler="category_selection_changed_cb" object="PpOptionsDialog" swapped="yes"/>
+                              </object>
+                            </child>
+                          </object>
+                        </child>
+                      </object>
+                    </child>
+                    <child>
+                      <object class="GtkNotebook" id="notebook">
+                        <property name="tab_pos">left</property>
+                        <property name="show_tabs">False</property>
+                        <property name="hexpand">True</property>
+                        <property name="vexpand">True</property>
+                      </object>
+                    </child>
+                  </object>
+                </child>
+              </object>
+            </child>
+            <child>
+              <object class="GtkSpinner" id="spinner">
+                <property name="halign">center</property>
+                <property name="valign">center</property>
+                <property name="width_request">24</property>
+                <property name="height_request">24</property>
+              </object>
+            </child>
+          </object>
+        </child>
+      </object>
+    </child>
+  </template>
+</interface>
diff --git a/panels/printers/pp-ppd-option-widget.c b/panels/printers/pp-ppd-option-widget.c
new file mode 100644
index 0000000..0375b16
--- /dev/null
+++ b/panels/printers/pp-ppd-option-widget.c
@@ -0,0 +1,535 @@
+/* -*- 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 2 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, see <http://www.gnu.org/licenses/>.
+ *
+ * Author: Marek Kasik <mkasik@redhat.com>
+ */
+
+#include "config.h"
+#include <stdlib.h>
+#include <string.h>
+#include <stdio.h>
+#include <ctype.h>
+#include <glib/gi18n-lib.h>
+#include <glib/gstdio.h>
+
+#include "pp-ppd-option-widget.h"
+#include "pp-utils.h"
+
+static void pp_ppd_option_widget_finalize (GObject *object);
+
+static gboolean construct_widget   (PpPPDOptionWidget *self);
+static void     update_widget      (PpPPDOptionWidget *self);
+static void     update_widget_real (PpPPDOptionWidget *self);
+
+struct _PpPPDOptionWidget
+{
+  GtkBox parent_instance;
+
+  GtkWidget *switch_button;
+  GtkWidget *dropdown;
+  GtkWidget *image;
+  GtkWidget *box;
+
+  ppd_option_t *option;
+
+  gchar *printer_name;
+  gchar *option_name;
+
+  cups_dest_t *destination;
+  gboolean     destination_set;
+
+  gchar    *ppd_filename;
+  gboolean  ppd_filename_set;
+
+  GCancellable *cancellable;
+};
+
+G_DEFINE_TYPE (PpPPDOptionWidget, pp_ppd_option_widget, GTK_TYPE_BOX)
+
+/* This list comes from Gtk+ */
+static const struct {
+  const char *keyword;
+  const char *choice;
+  const char *translation;
+} ppd_choice_translations[] = {
+  { "Duplex", "None", N_("One Sided") },
+  /* Translators: this is an option of "Two Sided" */
+  { "Duplex", "DuplexNoTumble", N_("Long Edge (Standard)") },
+  /* Translators: this is an option of "Two Sided" */
+  { "Duplex", "DuplexTumble", N_("Short Edge (Flip)") },
+  /* Translators: this is an option of "Paper Source" */
+  { "InputSlot", "Auto", N_("Auto Select") },
+  /* Translators: this is an option of "Paper Source" */
+  { "InputSlot", "AutoSelect", N_("Auto Select") },
+  /* Translators: this is an option of "Paper Source" */
+  { "InputSlot", "Default", N_("Printer Default") },
+  /* Translators: this is an option of "Paper Source" */
+  { "InputSlot", "None", N_("Printer Default") },
+  /* Translators: this is an option of "Paper Source" */
+  { "InputSlot", "PrinterDefault", N_("Printer Default") },
+  /* Translators: this is an option of "Paper Source" */
+  { "InputSlot", "Unspecified", N_("Auto Select") },
+  /* Translators: this is an option of "Resolution" */
+  { "Resolution", "default", N_("Printer Default") },
+  /* Translators: this is an option of "GhostScript" */
+  { "PreFilter", "EmbedFonts", N_("Embed GhostScript fonts only") },
+  /* Translators: this is an option of "GhostScript" */
+  { "PreFilter", "Level1", N_("Convert to PS level 1") },
+  /* Translators: this is an option of "GhostScript" */
+  { "PreFilter", "Level2", N_("Convert to PS level 2") },
+  /* Translators: this is an option of "GhostScript" */
+  { "PreFilter", "No", N_("No pre-filtering") },
+};
+
+static ppd_option_t *
+cups_option_copy (ppd_option_t *option)
+{
+  ppd_option_t *result;
+  gint          i;
+
+  result = g_new0 (ppd_option_t, 1);
+
+  *result = *option;
+
+  result->choices = g_new (ppd_choice_t, result->num_choices);
+  for (i = 0; i < result->num_choices; i++)
+    {
+      result->choices[i] = option->choices[i];
+      result->choices[i].code = g_strdup (option->choices[i].code);
+      result->choices[i].option = result;
+    }
+
+  return result;
+}
+
+static void
+cups_option_free (ppd_option_t *option)
+{
+  gint i;
+
+  if (option)
+    {
+      for (i = 0; i < option->num_choices; i++)
+        g_free (option->choices[i].code);
+
+      g_free (option->choices);
+      g_free (option);
+    }
+}
+
+static void
+pp_ppd_option_widget_class_init (PpPPDOptionWidgetClass *class)
+{
+  GObjectClass *object_class;
+
+  object_class = G_OBJECT_CLASS (class);
+
+  object_class->finalize = pp_ppd_option_widget_finalize;
+}
+
+static void
+pp_ppd_option_widget_init (PpPPDOptionWidget *self)
+{
+  gtk_orientable_set_orientation (GTK_ORIENTABLE (self),
+                                  GTK_ORIENTATION_HORIZONTAL);
+}
+
+static void
+pp_ppd_option_widget_finalize (GObject *object)
+{
+  PpPPDOptionWidget *self = PP_PPD_OPTION_WIDGET (object);
+
+  g_cancellable_cancel (self->cancellable);
+  if (self->ppd_filename)
+    g_unlink (self->ppd_filename);
+
+  g_clear_pointer (&self->option, cups_option_free);
+  g_clear_pointer (&self->printer_name, g_free);
+  g_clear_pointer (&self->option_name, g_free);
+  if (self->destination)
+    {
+      cupsFreeDests (1, self->destination);
+      self->destination = NULL;
+    }
+  g_clear_pointer (&self->ppd_filename, g_free);
+  g_clear_object (&self->cancellable);
+
+  G_OBJECT_CLASS (pp_ppd_option_widget_parent_class)->finalize (object);
+}
+
+static const gchar *
+ppd_choice_translate (ppd_choice_t *choice)
+{
+  const gchar *keyword = choice->option->keyword;
+  gint         i;
+
+  for (i = 0; i < G_N_ELEMENTS (ppd_choice_translations); i++)
+    {
+      if (g_strcmp0 (ppd_choice_translations[i].keyword, keyword) == 0 &&
+          g_strcmp0 (ppd_choice_translations[i].choice, choice->choice) == 0)
+        {
+          return _(ppd_choice_translations[i].translation);
+        }
+    }
+
+  return choice->text;
+}
+
+GtkWidget *
+pp_ppd_option_widget_new (ppd_option_t *option,
+                          const gchar  *printer_name)
+{
+  PpPPDOptionWidget *self = NULL;
+
+  if (option && printer_name)
+    {
+      self = g_object_new (PP_TYPE_PPD_OPTION_WIDGET, NULL);
+
+      self->printer_name = g_strdup (printer_name);
+      self->option = cups_option_copy (option);
+      self->option_name = g_strdup (option->keyword);
+
+      if (construct_widget (self))
+        {
+          update_widget_real (self);
+        }
+      else
+        {
+          g_object_ref_sink (self);
+          g_object_unref (self);
+          self = NULL;
+        }
+    }
+
+  return (GtkWidget *) self;
+}
+
+static GtkWidget *
+dropdown_new (void)
+{
+  GtkStringList *store = NULL;
+  GtkWidget     *dropdown;
+
+  store = gtk_string_list_new (NULL);
+
+  dropdown = gtk_drop_down_new (G_LIST_MODEL (store), NULL);
+
+  return dropdown;
+}
+
+static void
+dropdown_append (GtkWidget   *dropdown,
+                 const gchar *display_text)
+{
+  GtkStringList *store;
+
+  store = GTK_STRING_LIST (gtk_drop_down_get_model (GTK_DROP_DOWN (dropdown)));
+
+  gtk_string_list_append (store, display_text);
+}
+
+static void
+dropdown_set (GtkWidget    *dropdown,
+              ppd_option_t *option,
+              const gchar  *value)
+{
+  for (guint i = 0; i < option->num_choices; i++)
+    {
+      if (g_strcmp0 (option->choices[i].choice, value) == 0)
+        {
+          gtk_drop_down_set_selected (GTK_DROP_DOWN (dropdown), i);
+          break;
+        }
+    }
+}
+
+static char *
+dropdown_get (GtkWidget    *dropdown,
+              ppd_option_t *option)
+{
+  guint          selected_item;
+  gchar         *value = NULL;
+
+  selected_item = gtk_drop_down_get_selected (GTK_DROP_DOWN (dropdown));
+
+  if (selected_item != GTK_INVALID_LIST_POSITION)
+    {
+      value = option->choices[selected_item].choice;
+    }
+
+  return value;
+}
+
+static void
+printer_add_option_async_cb (gboolean success,
+                             gpointer user_data)
+{
+  PpPPDOptionWidget *self = user_data;
+
+  update_widget (user_data);
+  g_clear_object (&self->cancellable);
+}
+
+static void
+switch_changed_cb (PpPPDOptionWidget *self)
+{
+  gchar                    **values;
+
+  values = g_new0 (gchar *, 2);
+
+  if (gtk_switch_get_active (GTK_SWITCH (self->switch_button)))
+    values[0] = g_strdup ("True");
+  else
+    values[0] = g_strdup ("False");
+
+  g_cancellable_cancel (self->cancellable);
+  g_clear_object (&self->cancellable);
+
+  self->cancellable = g_cancellable_new ();
+  printer_add_option_async (self->printer_name,
+                            self->option_name,
+                            values,
+                            FALSE,
+                            self->cancellable,
+                            printer_add_option_async_cb,
+                            self);
+
+  g_strfreev (values);
+}
+
+static void
+dropdown_changed_cb (PpPPDOptionWidget *self)
+{
+  gchar                    **values;
+
+  values = g_new0 (gchar *, 2);
+  values[0] = g_strdup (dropdown_get (self->dropdown, self->option));
+
+  g_cancellable_cancel (self->cancellable);
+  g_clear_object (&self->cancellable);
+
+  self->cancellable = g_cancellable_new ();
+  printer_add_option_async (self->printer_name,
+                            self->option_name,
+                            values,
+                            FALSE,
+                            self->cancellable,
+                            printer_add_option_async_cb,
+                            self);
+
+  g_strfreev (values);
+}
+
+static gboolean
+construct_widget (PpPPDOptionWidget *self)
+{
+  gint                      i;
+
+  /* Don't show options which has only one choice */
+  if (self->option && self->option->num_choices > 1)
+    {
+      switch (self->option->ui)
+        {
+          case PPD_UI_BOOLEAN:
+              self->switch_button = gtk_switch_new ();
+
+              g_signal_connect_object (self->switch_button, "notify::active", G_CALLBACK (switch_changed_cb), self, G_CONNECT_SWAPPED);
+              gtk_box_append (GTK_BOX (self), self->switch_button);
+              break;
+
+          case PPD_UI_PICKONE:
+              self->dropdown = dropdown_new ();
+
+              for (i = 0; i < self->option->num_choices; i++)
+                {
+                  dropdown_append (self->dropdown,
+                                   ppd_choice_translate (&self->option->choices[i]));
+                }
+
+              gtk_box_append (GTK_BOX (self), self->dropdown);
+              g_signal_connect_object (self->dropdown, "notify::selected", G_CALLBACK (dropdown_changed_cb), self, G_CONNECT_SWAPPED);
+              break;
+
+          case PPD_UI_PICKMANY:
+              self->dropdown = dropdown_new ();
+
+              for (i = 0; i < self->option->num_choices; i++)
+                {
+                  dropdown_append (self->dropdown,
+                                   ppd_choice_translate (&self->option->choices[i]));
+                }
+
+              gtk_box_append (GTK_BOX (self), self->dropdown);
+              g_signal_connect_object (self->dropdown, "notify::selected", G_CALLBACK (dropdown_changed_cb), self, G_CONNECT_SWAPPED);
+              break;
+
+          default:
+              break;
+        }
+
+      self->image = gtk_image_new_from_icon_name ("dialog-warning-symbolic");
+      if (!self->image)
+        self->image = gtk_image_new_from_icon_name ("dialog-warning");
+      gtk_box_append (GTK_BOX (self), self->image);
+
+      return TRUE;
+    }
+  else
+    {
+      return FALSE;
+    }
+}
+
+static void
+update_widget_real (PpPPDOptionWidget *self)
+{
+  ppd_option_t             *option = NULL, *iter;
+  ppd_file_t               *ppd_file;
+  gint                      i;
+
+  if (self->ppd_filename_set && self->ppd_filename)
+    {
+      ppd_file = ppdOpenFile (self->ppd_filename);
+      ppdLocalize (ppd_file);
+
+      if (ppd_file)
+        {
+          ppdMarkDefaults (ppd_file);
+
+          for (iter = ppdFirstOption(ppd_file); iter; iter = ppdNextOption(ppd_file))
+            {
+              if (g_str_equal (iter->keyword, self->option_name))
+                {
+                  g_clear_pointer (&self->option, cups_option_free);
+                  self->option = cups_option_copy (iter);
+                  break;
+                }
+            }
+
+          ppdClose (ppd_file);
+        }
+
+      g_unlink (self->ppd_filename);
+      g_free (self->ppd_filename);
+      self->ppd_filename = NULL;
+    }
+
+  option = self->option;
+
+  if (option)
+    {
+      g_autofree gchar *value = NULL;
+
+      for (i = 0; i < option->num_choices; i++)
+        if (option->choices[i].marked)
+          value = g_strdup (option->choices[i].choice);
+
+      if (value == NULL)
+        value = g_strdup (option->defchoice);
+
+      if (value)
+        {
+          switch (option->ui)
+            {
+              case PPD_UI_BOOLEAN:
+                g_signal_handlers_block_by_func (self->switch_button, switch_changed_cb, self);
+                if (g_ascii_strcasecmp (value, "True") == 0)
+                  gtk_switch_set_active (GTK_SWITCH (self->switch_button), TRUE);
+                else
+                  gtk_switch_set_active (GTK_SWITCH (self->switch_button), FALSE);
+                g_signal_handlers_unblock_by_func (self->switch_button, switch_changed_cb, self);
+                break;
+
+              case PPD_UI_PICKONE:
+                g_signal_handlers_block_by_func (self->dropdown, dropdown_changed_cb, self);
+                dropdown_set (self->dropdown, option, value);
+                g_signal_handlers_unblock_by_func (self->dropdown, dropdown_changed_cb, self);
+                break;
+
+              case PPD_UI_PICKMANY:
+                g_signal_handlers_block_by_func (self->dropdown, dropdown_changed_cb, self);
+                dropdown_set (self->dropdown, option, value);
+                g_signal_handlers_unblock_by_func (self->dropdown, dropdown_changed_cb, self);
+                break;
+
+              default:
+                break;
+            }
+        }
+
+      if (option->conflicted)
+        gtk_widget_show (self->image);
+      else
+        gtk_widget_hide (self->image);
+    }
+}
+
+static void
+get_named_dest_cb (cups_dest_t *dest,
+                   gpointer     user_data)
+{
+  PpPPDOptionWidget *self = user_data;
+
+  if (self->destination)
+    cupsFreeDests (1, self->destination);
+
+  self->destination = dest;
+  self->destination_set = TRUE;
+
+  if (self->ppd_filename_set)
+    {
+      update_widget_real (self);
+    }
+}
+
+static void
+printer_get_ppd_cb (const gchar *ppd_filename,
+                    gpointer     user_data)
+{
+  PpPPDOptionWidget *self = user_data;
+
+  if (self->ppd_filename)
+    {
+      g_unlink (self->ppd_filename);
+      g_free (self->ppd_filename);
+    }
+
+  self->ppd_filename = g_strdup (ppd_filename);
+  self->ppd_filename_set = TRUE;
+
+  if (self->destination_set)
+    {
+      update_widget_real (self);
+    }
+}
+
+static void
+update_widget (PpPPDOptionWidget *self)
+{
+  self->ppd_filename_set = FALSE;
+  self->destination_set = FALSE;
+
+  get_named_dest_async (self->printer_name,
+                        get_named_dest_cb,
+                        self);
+
+  printer_get_ppd_async (self->printer_name,
+                         NULL,
+                         0,
+                         printer_get_ppd_cb,
+                         self);
+}
diff --git a/panels/printers/pp-ppd-option-widget.h b/panels/printers/pp-ppd-option-widget.h
new file mode 100644
index 0000000..b558e51
--- /dev/null
+++ b/panels/printers/pp-ppd-option-widget.h
@@ -0,0 +1,35 @@
+/* -*- 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 2 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, see <http://www.gnu.org/licenses/>.
+ *
+ * Author: Marek Kasik <mkasik@redhat.com>
+ */
+
+#pragma once
+
+#include <gtk/gtk.h>
+#include <cups/cups.h>
+#include <cups/ppd.h>
+
+G_BEGIN_DECLS
+
+#define PP_TYPE_PPD_OPTION_WIDGET (pp_ppd_option_widget_get_type ())
+G_DECLARE_FINAL_TYPE (PpPPDOptionWidget, pp_ppd_option_widget, PP, PPD_OPTION_WIDGET, GtkBox)
+
+GtkWidget   *pp_ppd_option_widget_new      (ppd_option_t *source,
+                                            const gchar  *printer_name);
+
+G_END_DECLS
diff --git a/panels/printers/pp-ppd-selection-dialog.c b/panels/printers/pp-ppd-selection-dialog.c
new file mode 100644
index 0000000..13f7274
--- /dev/null
+++ b/panels/printers/pp-ppd-selection-dialog.c
@@ -0,0 +1,378 @@
+/* -*- 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 2 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, see <http://www.gnu.org/licenses/>.
+ *
+ * Author: Marek Kasik <mkasik@redhat.com>
+ */
+
+#include "config.h"
+
+#include <unistd.h>
+#include <stdlib.h>
+#include <sys/types.h>
+#include <sys/wait.h>
+
+#include <glib.h>
+#include <glib/gi18n.h>
+#include <glib/gstdio.h>
+#include <gtk/gtk.h>
+
+#include "pp-ppd-selection-dialog.h"
+
+enum
+{
+  PPD_NAMES_COLUMN = 0,
+  PPD_DISPLAY_NAMES_COLUMN
+};
+
+enum
+{
+  PPD_MANUFACTURERS_NAMES_COLUMN = 0,
+  PPD_MANUFACTURERS_DISPLAY_NAMES_COLUMN
+};
+
+
+struct _PpPPDSelectionDialog {
+  GtkDialog parent_instance;
+
+  GtkButton   *ppd_selection_select_button;
+  GtkSpinner  *ppd_spinner;
+  GtkLabel    *progress_label;
+  GtkTreeView *ppd_selection_manufacturers_treeview;
+  GtkTreeView *ppd_selection_models_treeview;
+
+  UserResponseCallback user_callback;
+  gpointer             user_data;
+
+  gchar           *ppd_name;
+  gchar           *ppd_display_name;
+  gchar           *manufacturer;
+
+  PPDList *list;
+};
+
+G_DEFINE_TYPE (PpPPDSelectionDialog, pp_ppd_selection_dialog, GTK_TYPE_DIALOG)
+
+static void
+manufacturer_selection_changed_cb (PpPPDSelectionDialog *self)
+{
+  GtkTreeView  *treeview;
+  g_autoptr(GtkListStore) store = NULL;
+  GtkTreeModel *model;
+  GtkTreeIter   iter;
+  GtkTreeView  *models_treeview;
+  gchar        *manufacturer_name = NULL;
+  gint          i, index;
+
+  treeview = self->ppd_selection_manufacturers_treeview;
+  if (gtk_tree_selection_get_selected (gtk_tree_view_get_selection (treeview), &model, &iter))
+    {
+      gtk_tree_model_get (model, &iter,
+                          PPD_MANUFACTURERS_NAMES_COLUMN, &manufacturer_name,
+                          -1);
+    }
+
+  if (manufacturer_name)
+    {
+      index = -1;
+      for (i = 0; i < self->list->num_of_manufacturers; i++)
+        {
+          if (g_strcmp0 (manufacturer_name,
+                         self->list->manufacturers[i]->manufacturer_name) == 0)
+            {
+              index = i;
+              break;
+            }
+        }
+
+      if (index >= 0)
+        {
+          models_treeview = self->ppd_selection_models_treeview;
+
+          store = gtk_list_store_new (2, G_TYPE_STRING, G_TYPE_STRING);
+
+          for (i = 0; i < self->list->manufacturers[index]->num_of_ppds; i++)
+            {
+              gtk_list_store_append (store, &iter);
+              gtk_list_store_set (store, &iter,
+                                  PPD_NAMES_COLUMN, self->list->manufacturers[index]->ppds[i]->ppd_name,
+                                  PPD_DISPLAY_NAMES_COLUMN, self->list->manufacturers[index]->ppds[i]->ppd_display_name,
+                                  -1);
+            }
+
+          gtk_tree_view_set_model (models_treeview, GTK_TREE_MODEL (store));
+          gtk_tree_view_columns_autosize (models_treeview);
+        }
+
+      g_free (manufacturer_name);
+    }
+}
+
+static void
+model_selection_changed_cb (PpPPDSelectionDialog *self)
+{
+  GtkTreeView  *treeview;
+  GtkTreeModel *model;
+  GtkTreeIter   iter;
+  GtkButton    *ppd_select_button;
+  gchar        *model_name = NULL;
+
+  treeview = self->ppd_selection_models_treeview;
+  if (gtk_tree_selection_get_selected (gtk_tree_view_get_selection (treeview), &model, &iter))
+    {
+      gtk_tree_model_get (model, &iter,
+                          PPD_NAMES_COLUMN, &model_name,
+                          -1);
+    }
+
+  ppd_select_button = self->ppd_selection_select_button;
+
+  if (model_name)
+    {
+      gtk_widget_set_sensitive (GTK_WIDGET (ppd_select_button), TRUE);
+      g_free (model_name);
+    }
+  else
+    {
+      gtk_widget_set_sensitive (GTK_WIDGET (ppd_select_button), FALSE);
+    }
+}
+
+static void
+fill_ppds_list (PpPPDSelectionDialog *self)
+{
+  GtkTreeSelection *selection;
+  g_autoptr(GtkListStore) store = NULL;
+  GtkTreePath      *path;
+  GtkTreeView      *treeview;
+  GtkTreeIter       iter;
+  GtkTreeIter      *preselect_iter = NULL;
+  gint              i;
+
+  gtk_widget_hide (GTK_WIDGET (self->ppd_spinner));
+  gtk_spinner_stop (self->ppd_spinner);
+
+  gtk_widget_hide (GTK_WIDGET (self->progress_label));
+
+  treeview = self->ppd_selection_manufacturers_treeview;
+
+  if (self->list)
+    {
+      store = gtk_list_store_new (2, G_TYPE_STRING, G_TYPE_STRING);
+
+      for (i = 0; i < self->list->num_of_manufacturers; i++)
+        {
+          gtk_list_store_append (store, &iter);
+          gtk_list_store_set (store, &iter,
+                              PPD_MANUFACTURERS_NAMES_COLUMN, self->list->manufacturers[i]->manufacturer_name,
+                              PPD_MANUFACTURERS_DISPLAY_NAMES_COLUMN, self->list->manufacturers[i]->manufacturer_display_name,
+                              -1);
+
+          if (g_strcmp0 (self->manufacturer,
+                         self->list->manufacturers[i]->manufacturer_display_name) == 0)
+            {
+              preselect_iter = gtk_tree_iter_copy (&iter);
+            }
+        }
+
+      gtk_tree_view_set_model (treeview, GTK_TREE_MODEL (store));
+
+      if (preselect_iter &&
+          (selection = gtk_tree_view_get_selection (treeview)) != NULL)
+        {
+          gtk_tree_selection_select_iter (selection, preselect_iter);
+          path = gtk_tree_model_get_path (GTK_TREE_MODEL (store), preselect_iter);
+          gtk_tree_view_scroll_to_cell (treeview, path, NULL, TRUE, 0.5, 0.0);
+          gtk_tree_path_free (path);
+          gtk_tree_iter_free (preselect_iter);
+        }
+    }
+}
+
+static void
+populate_dialog (PpPPDSelectionDialog *self)
+{
+  GtkTreeViewColumn *column;
+  GtkCellRenderer   *renderer;
+  GtkTreeView       *manufacturers_treeview;
+  GtkTreeView       *models_treeview;
+  GtkWidget         *header;
+
+  manufacturers_treeview = self->ppd_selection_manufacturers_treeview;
+
+  renderer = gtk_cell_renderer_text_new ();
+  gtk_cell_renderer_set_padding (renderer, 10, 0);
+
+  /* Translators: Name of column showing printer manufacturers */
+  column = gtk_tree_view_column_new_with_attributes (_("Manufacturer"), renderer,
+                                                     "text", PPD_MANUFACTURERS_DISPLAY_NAMES_COLUMN, NULL);
+  gtk_tree_view_column_set_expand (column, TRUE);
+  header = gtk_label_new (gtk_tree_view_column_get_title (column));
+  gtk_widget_set_margin_start (header, 10);
+  gtk_tree_view_column_set_widget (column, header);
+  gtk_widget_show (header);
+  gtk_tree_view_append_column (manufacturers_treeview, column);
+
+
+  models_treeview = self->ppd_selection_models_treeview;
+
+  renderer = gtk_cell_renderer_text_new ();
+  gtk_cell_renderer_set_padding (renderer, 10, 0);
+
+  /* Translators: Name of column showing printer drivers */
+  column = gtk_tree_view_column_new_with_attributes (_("Driver"), renderer,
+                                                     "text", PPD_DISPLAY_NAMES_COLUMN,
+                                                     NULL);
+  gtk_tree_view_column_set_expand (column, TRUE);
+  header = gtk_label_new (gtk_tree_view_column_get_title (column));
+  gtk_widget_set_margin_start (header, 10);
+  gtk_tree_view_column_set_widget (column, header);
+  gtk_widget_show (header);
+  gtk_tree_view_append_column (models_treeview, column);
+
+
+  g_signal_connect_object (gtk_tree_view_get_selection (models_treeview),
+                           "changed", G_CALLBACK (model_selection_changed_cb), self, G_CONNECT_SWAPPED);
+
+  g_signal_connect_object (gtk_tree_view_get_selection (manufacturers_treeview),
+                           "changed", G_CALLBACK (manufacturer_selection_changed_cb), self, G_CONNECT_SWAPPED);
+
+  if (!self->list)
+    {
+      gtk_widget_show (GTK_WIDGET (self->ppd_spinner));
+      gtk_spinner_start (self->ppd_spinner);
+
+      gtk_widget_show (GTK_WIDGET (self->progress_label));
+    }
+  else
+    {
+      fill_ppds_list (self);
+    }
+}
+
+static void
+ppd_selection_dialog_response_cb (PpPPDSelectionDialog *self,
+                                  gint       response_id)
+{
+  GtkTreeSelection *selection;
+  GtkTreeModel     *model;
+  GtkTreeView      *models_treeview;
+  GtkTreeIter       iter;
+
+  if (response_id == GTK_RESPONSE_OK)
+    {
+      models_treeview = self->ppd_selection_models_treeview;
+
+      if (models_treeview)
+        {
+          selection = gtk_tree_view_get_selection (models_treeview);
+
+          if (selection)
+            {
+              if (gtk_tree_selection_get_selected (selection, &model, &iter))
+                {
+                  gtk_tree_model_get (model, &iter,
+                                      PPD_NAMES_COLUMN, &self->ppd_name,
+                                      PPD_DISPLAY_NAMES_COLUMN, &self->ppd_display_name,
+                                      -1);
+                }
+            }
+        }
+    }
+
+  self->user_callback (GTK_DIALOG (self), response_id, self->user_data);
+}
+
+PpPPDSelectionDialog *
+pp_ppd_selection_dialog_new (PPDList              *ppd_list,
+                             const gchar          *manufacturer,
+                             UserResponseCallback  user_callback,
+                             gpointer              user_data)
+{
+  PpPPDSelectionDialog *self;
+
+  self = g_object_new (pp_ppd_selection_dialog_get_type (), NULL);
+
+  self->user_callback = user_callback;
+  self->user_data = user_data;
+
+  self->list = ppd_list_copy (ppd_list);
+
+  self->manufacturer = get_standard_manufacturers_name (manufacturer);
+
+  /* connect signal */
+  g_signal_connect_object (self, "response", G_CALLBACK (ppd_selection_dialog_response_cb), self, G_CONNECT_SWAPPED);
+
+  gtk_spinner_start (self->ppd_spinner);
+
+  populate_dialog (self);
+
+  return self;
+}
+
+static void
+pp_ppd_selection_dialog_dispose (GObject *object)
+{
+  PpPPDSelectionDialog *self = PP_PPD_SELECTION_DIALOG (object);
+
+  g_clear_pointer (&self->ppd_name, g_free);
+  g_clear_pointer (&self->ppd_display_name, g_free);
+  g_clear_pointer (&self->manufacturer, g_free);
+
+  G_OBJECT_CLASS (pp_ppd_selection_dialog_parent_class)->dispose (object);
+}
+
+void
+pp_ppd_selection_dialog_class_init (PpPPDSelectionDialogClass *klass)
+{
+  GtkWidgetClass *widget_class = GTK_WIDGET_CLASS (klass);
+  GObjectClass   *object_class = G_OBJECT_CLASS (klass);
+
+  gtk_widget_class_set_template_from_resource (widget_class, "/org/gnome/control-center/printers/ppd-selection-dialog.ui");
+  gtk_widget_class_bind_template_child (widget_class, PpPPDSelectionDialog, ppd_selection_select_button);
+  gtk_widget_class_bind_template_child (widget_class, PpPPDSelectionDialog, ppd_spinner);
+  gtk_widget_class_bind_template_child (widget_class, PpPPDSelectionDialog, progress_label);
+  gtk_widget_class_bind_template_child (widget_class, PpPPDSelectionDialog, ppd_selection_manufacturers_treeview);
+  gtk_widget_class_bind_template_child (widget_class, PpPPDSelectionDialog, ppd_selection_models_treeview);
+
+  object_class->dispose = pp_ppd_selection_dialog_dispose;
+}
+
+void
+pp_ppd_selection_dialog_init (PpPPDSelectionDialog *self)
+{
+  gtk_widget_init_template (GTK_WIDGET (self));
+}
+
+gchar *
+pp_ppd_selection_dialog_get_ppd_name (PpPPDSelectionDialog *self)
+{
+  return g_strdup (self->ppd_name);
+}
+
+gchar *
+pp_ppd_selection_dialog_get_ppd_display_name (PpPPDSelectionDialog *self)
+{
+  return g_strdup (self->ppd_display_name);
+}
+
+void
+pp_ppd_selection_dialog_set_ppd_list (PpPPDSelectionDialog *self,
+                                      PPDList              *list)
+{
+  self->list = list;
+  fill_ppds_list (self);
+}
diff --git a/panels/printers/pp-ppd-selection-dialog.h b/panels/printers/pp-ppd-selection-dialog.h
new file mode 100644
index 0000000..5b4ee22
--- /dev/null
+++ b/panels/printers/pp-ppd-selection-dialog.h
@@ -0,0 +1,40 @@
+/* -*- 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 2 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, see <http://www.gnu.org/licenses/>.
+ *
+ * Author: Marek Kasik <mkasik@redhat.com>
+ */
+
+#pragma once
+
+#include <gtk/gtk.h>
+#include "pp-utils.h"
+
+G_BEGIN_DECLS
+
+#define PP_TYPE_PPD_SELECTION_DIALOG (pp_ppd_selection_dialog_get_type ())
+G_DECLARE_FINAL_TYPE (PpPPDSelectionDialog, pp_ppd_selection_dialog, PP, PPD_SELECTION_DIALOG, GtkDialog)
+
+PpPPDSelectionDialog *pp_ppd_selection_dialog_new                  (PPDList                   *ppd_list,
+                                                                    const gchar               *manufacturer,
+                                                                    UserResponseCallback       user_callback,
+                                                                    gpointer                   user_data);
+gchar                *pp_ppd_selection_dialog_get_ppd_name         (PpPPDSelectionDialog      *dialog);
+gchar                *pp_ppd_selection_dialog_get_ppd_display_name (PpPPDSelectionDialog      *dialog);
+void                  pp_ppd_selection_dialog_set_ppd_list         (PpPPDSelectionDialog      *dialog,
+                                                                    PPDList                   *list);
+
+G_END_DECLS
diff --git a/panels/printers/pp-print-device.c b/panels/printers/pp-print-device.c
new file mode 100644
index 0000000..3ab0b07
--- /dev/null
+++ b/panels/printers/pp-print-device.c
@@ -0,0 +1,450 @@
+/* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 8 -*-
+ *
+ * Copyright 2015  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 2 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, see <http://www.gnu.org/licenses/>.
+ *
+ * Author: Marek Kasik <mkasik@redhat.com>
+ */
+
+#include "pp-print-device.h"
+
+struct _PpPrintDevice
+{
+  GObject   parent_instance;
+
+  gchar    *device_name;
+  gchar    *display_name;
+  gchar    *device_original_name;
+  gchar    *device_make_and_model;
+  gchar    *device_location;
+  gchar    *device_info;
+  gchar    *device_uri;
+  gchar    *device_id;
+  gchar    *device_ppd;
+  gchar    *host_name;
+  gint      host_port;
+  gboolean  is_authenticated_server;
+  gint      acquisition_method;
+  gboolean  is_network_device;
+};
+
+G_DEFINE_TYPE (PpPrintDevice, pp_print_device, G_TYPE_OBJECT);
+
+enum
+{
+  PROP_0 = 0,
+  PROP_DEVICE_NAME,
+  PROP_DISPLAY_NAME,
+  PROP_DEVICE_ORIGINAL_NAME,
+  PROP_DEVICE_MAKE_AND_MODEL,
+  PROP_DEVICE_LOCATION,
+  PROP_DEVICE_INFO,
+  PROP_DEVICE_URI,
+  PROP_DEVICE_ID,
+  PROP_DEVICE_PPD,
+  PROP_HOST_NAME,
+  PROP_HOST_PORT,
+  PROP_IS_AUTHENTICATED_SERVER,
+  PROP_ACQUISITION_METHOD,
+  PROP_IS_NETWORK_DEVICE
+};
+
+static void
+pp_print_device_finalize (GObject *object)
+{
+  PpPrintDevice *self = PP_PRINT_DEVICE (object);
+
+  g_clear_pointer (&self->device_name, g_free);
+  g_clear_pointer (&self->display_name, g_free);
+  g_clear_pointer (&self->device_original_name, g_free);
+  g_clear_pointer (&self->device_make_and_model, g_free);
+  g_clear_pointer (&self->device_location, g_free);
+  g_clear_pointer (&self->device_info, g_free);
+  g_clear_pointer (&self->device_uri, g_free);
+  g_clear_pointer (&self->device_id, g_free);
+  g_clear_pointer (&self->device_ppd, g_free);
+  g_clear_pointer (&self->host_name, g_free);
+
+  G_OBJECT_CLASS (pp_print_device_parent_class)->finalize (object);
+}
+
+static void
+pp_print_device_get_property (GObject    *object,
+                              guint       prop_id,
+                              GValue     *value,
+                              GParamSpec *param_spec)
+{
+  PpPrintDevice *self = PP_PRINT_DEVICE (object);
+
+  switch (prop_id)
+    {
+      case PROP_DEVICE_NAME:
+        g_value_set_string (value, self->device_name);
+        break;
+      case PROP_DISPLAY_NAME:
+        g_value_set_string (value, self->display_name);
+        break;
+      case PROP_DEVICE_ORIGINAL_NAME:
+        g_value_set_string (value, self->device_original_name);
+        break;
+      case PROP_DEVICE_MAKE_AND_MODEL:
+        g_value_set_string (value, self->device_make_and_model);
+        break;
+      case PROP_DEVICE_LOCATION:
+        g_value_set_string (value, self->device_location);
+        break;
+      case PROP_DEVICE_INFO:
+        g_value_set_string (value, self->device_info);
+        break;
+      case PROP_DEVICE_URI:
+        g_value_set_string (value, self->device_uri);
+        break;
+      case PROP_DEVICE_ID:
+        g_value_set_string (value, self->device_id);
+        break;
+      case PROP_DEVICE_PPD:
+        g_value_set_string (value, self->device_ppd);
+        break;
+      case PROP_HOST_NAME:
+        g_value_set_string (value, self->host_name);
+        break;
+      case PROP_HOST_PORT:
+        g_value_set_int (value, self->host_port);
+        break;
+      case PROP_IS_AUTHENTICATED_SERVER:
+        g_value_set_boolean (value, self->is_authenticated_server);
+        break;
+      case PROP_ACQUISITION_METHOD:
+        g_value_set_int (value, self->acquisition_method);
+        break;
+      case PROP_IS_NETWORK_DEVICE:
+        g_value_set_boolean (value, self->is_network_device);
+        break;
+      default:
+        G_OBJECT_WARN_INVALID_PROPERTY_ID (object,
+                                           prop_id,
+                                           param_spec);
+      break;
+    }
+}
+
+static void
+pp_print_device_set_property (GObject      *object,
+                              guint         prop_id,
+                              const GValue *value,
+                              GParamSpec   *param_spec)
+{
+  PpPrintDevice *self = PP_PRINT_DEVICE (object);
+
+  switch (prop_id)
+    {
+      case PROP_DEVICE_NAME:
+        g_free (self->device_name);
+        self->device_name = g_value_dup_string (value);
+        break;
+      case PROP_DISPLAY_NAME:
+        g_free (self->display_name);
+        self->display_name = g_value_dup_string (value);
+        break;
+      case PROP_DEVICE_ORIGINAL_NAME:
+        g_free (self->device_original_name);
+        self->device_original_name = g_value_dup_string (value);
+        break;
+      case PROP_DEVICE_MAKE_AND_MODEL:
+        g_free (self->device_make_and_model);
+        self->device_make_and_model = g_value_dup_string (value);
+        break;
+      case PROP_DEVICE_LOCATION:
+        g_free (self->device_location);
+        self->device_location = g_value_dup_string (value);
+        break;
+      case PROP_DEVICE_INFO:
+        g_free (self->device_info);
+        self->device_info = g_value_dup_string (value);
+        break;
+      case PROP_DEVICE_URI:
+        g_free (self->device_uri);
+        self->device_uri = g_value_dup_string (value);
+        break;
+      case PROP_DEVICE_ID:
+        g_free (self->device_id);
+        self->device_id = g_value_dup_string (value);
+        break;
+      case PROP_DEVICE_PPD:
+        g_free (self->device_ppd);
+        self->device_ppd = g_value_dup_string (value);
+        break;
+      case PROP_HOST_NAME:
+        g_free (self->host_name);
+        self->host_name = g_value_dup_string (value);
+        break;
+      case PROP_HOST_PORT:
+        self->host_port = g_value_get_int (value);
+        break;
+      case PROP_IS_AUTHENTICATED_SERVER:
+        self->is_authenticated_server = g_value_get_boolean (value);
+        break;
+      case PROP_ACQUISITION_METHOD:
+        self->acquisition_method = g_value_get_int (value);
+        break;
+      case PROP_IS_NETWORK_DEVICE:
+        self->is_network_device = g_value_get_boolean (value);
+        break;
+      default:
+        G_OBJECT_WARN_INVALID_PROPERTY_ID (object,
+                                           prop_id,
+                                           param_spec);
+        break;
+    }
+}
+
+static void
+pp_print_device_class_init (PpPrintDeviceClass *klass)
+{
+  GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
+
+  gobject_class->set_property = pp_print_device_set_property;
+  gobject_class->get_property = pp_print_device_get_property;
+
+  gobject_class->finalize = pp_print_device_finalize;
+
+  g_object_class_install_property (gobject_class,
+                                   PROP_DEVICE_NAME,
+                                   g_param_spec_string ("device-name",
+                                                        "Device name",
+                                                        "Name of the device",
+                                                        NULL,
+                                                        G_PARAM_READWRITE));
+
+  g_object_class_install_property (gobject_class,
+                                   PROP_DISPLAY_NAME,
+                                   g_param_spec_string ("display-name",
+                                                        "Display name",
+                                                        "Name of the device formatted for users",
+                                                        NULL,
+                                                        G_PARAM_READWRITE));
+
+  g_object_class_install_property (gobject_class,
+                                   PROP_DEVICE_ORIGINAL_NAME,
+                                   g_param_spec_string ("device-original-name",
+                                                        "Device original name",
+                                                        "Original name of the device",
+                                                        NULL,
+                                                        G_PARAM_READWRITE));
+
+  g_object_class_install_property (gobject_class,
+                                   PROP_DEVICE_MAKE_AND_MODEL,
+                                   g_param_spec_string ("device-make-and-model",
+                                                        "Device make and model",
+                                                        "Make and model of the device",
+                                                        NULL,
+                                                        G_PARAM_READWRITE));
+
+  g_object_class_install_property (gobject_class,
+                                   PROP_DEVICE_LOCATION,
+                                   g_param_spec_string ("device-location",
+                                                        "Device location",
+                                                        "Locaton of the device",
+                                                        NULL,
+                                                        G_PARAM_READWRITE));
+
+  g_object_class_install_property (gobject_class,
+                                   PROP_DEVICE_INFO,
+                                   g_param_spec_string ("device-info",
+                                                        "Device info",
+                                                        "Information about the device",
+                                                        NULL,
+                                                        G_PARAM_READWRITE));
+
+  g_object_class_install_property (gobject_class,
+                                   PROP_DEVICE_URI,
+                                   g_param_spec_string ("device-uri",
+                                                        "Device URI",
+                                                        "URI of the device",
+                                                        NULL,
+                                                        G_PARAM_READWRITE));
+
+  g_object_class_install_property (gobject_class,
+                                   PROP_DEVICE_ID,
+                                   g_param_spec_string ("device-id",
+                                                        "DeviceID",
+                                                        "DeviceID of the device",
+                                                        NULL,
+                                                        G_PARAM_READWRITE));
+
+  g_object_class_install_property (gobject_class,
+                                   PROP_DEVICE_PPD,
+                                   g_param_spec_string ("device-ppd",
+                                                        "Device PPD",
+                                                        "Name of the PPD of the device",
+                                                        NULL,
+                                                        G_PARAM_READWRITE));
+
+  g_object_class_install_property (gobject_class,
+                                   PROP_HOST_NAME,
+                                   g_param_spec_string ("host-name",
+                                                        "Host name",
+                                                        "Hostname of the device",
+                                                        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, 0,
+                                                     G_PARAM_READWRITE));
+
+  g_object_class_install_property (gobject_class,
+                                   PROP_IS_AUTHENTICATED_SERVER,
+                                   g_param_spec_boolean ("is-authenticated-server",
+                                                         "Is authenticated server",
+                                                         "Whether the device is a server which needs authentication",
+                                                         FALSE,
+                                                         G_PARAM_READWRITE));
+
+  g_object_class_install_property (gobject_class,
+                                   PROP_ACQUISITION_METHOD,
+                                   g_param_spec_int ("acquisition-method",
+                                                     "Acquisition method",
+                                                     "Acquisition method of the device",
+                                                     0, G_MAXINT32, 0,
+                                                     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 device is a network device",
+                                                         FALSE,
+                                                         G_PARAM_READWRITE));
+}
+
+static void
+pp_print_device_init (PpPrintDevice *self)
+{
+}
+
+PpPrintDevice *
+pp_print_device_new ()
+{
+  return g_object_new (PP_TYPE_PRINT_DEVICE, NULL);
+}
+
+gchar *
+pp_print_device_get_device_name (PpPrintDevice *self)
+{
+  return self->device_name;
+}
+
+gchar *
+pp_print_device_get_display_name (PpPrintDevice *self)
+{
+  return self->display_name;
+}
+
+gchar *
+pp_print_device_get_device_original_name (PpPrintDevice *self)
+{
+  return self->device_original_name;
+}
+
+gchar *
+pp_print_device_get_device_make_and_model (PpPrintDevice *self)
+{
+  return self->device_make_and_model;
+}
+
+gchar *
+pp_print_device_get_device_location (PpPrintDevice *self)
+{
+  return self->device_location;
+}
+
+gchar *
+pp_print_device_get_device_info (PpPrintDevice *self)
+{
+  return self->device_info;
+}
+
+gchar *
+pp_print_device_get_device_uri (PpPrintDevice *self)
+{
+  return self->device_uri;
+}
+
+gchar *
+pp_print_device_get_device_id (PpPrintDevice *self)
+{
+  return self->device_id;
+}
+
+gchar *
+pp_print_device_get_device_ppd (PpPrintDevice *self)
+{
+  return self->device_ppd;
+}
+
+gchar *
+pp_print_device_get_host_name (PpPrintDevice *self)
+{
+  return self->host_name;
+}
+
+gint
+pp_print_device_get_host_port (PpPrintDevice *self)
+{
+  return self->host_port;
+}
+
+gboolean
+pp_print_device_is_authenticated_server (PpPrintDevice *self)
+{
+  return self->is_authenticated_server;
+}
+
+gint
+pp_print_device_get_acquisition_method (PpPrintDevice *self)
+{
+  return self->acquisition_method;
+}
+
+gboolean
+pp_print_device_is_network_device (PpPrintDevice *self)
+{
+  return self->is_network_device;
+}
+
+PpPrintDevice *
+pp_print_device_copy (PpPrintDevice *self)
+{
+  return g_object_new (PP_TYPE_PRINT_DEVICE,
+                       "device-name", pp_print_device_get_device_name (self),
+                       "display-name", pp_print_device_get_display_name (self),
+                       "device-original-name", pp_print_device_get_device_original_name (self),
+                       "device-make-and-model", pp_print_device_get_device_make_and_model (self),
+                       "device-location", pp_print_device_get_device_location (self),
+                       "device-info", pp_print_device_get_device_info (self),
+                       "device-uri", pp_print_device_get_device_uri (self),
+                       "device-id", pp_print_device_get_device_id (self),
+                       "device-ppd", pp_print_device_get_device_ppd (self),
+                       "host-name", pp_print_device_get_host_name (self),
+                       "host-port", pp_print_device_get_host_port (self),
+                       "is-authenticated-server", pp_print_device_is_authenticated_server (self),
+                       "acquisition-method", pp_print_device_get_acquisition_method (self),
+                       "is-network-device", pp_print_device_is_network_device (self),
+                       NULL);
+}
diff --git a/panels/printers/pp-print-device.h b/panels/printers/pp-print-device.h
new file mode 100644
index 0000000..a271254
--- /dev/null
+++ b/panels/printers/pp-print-device.h
@@ -0,0 +1,48 @@
+/* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 8 -*-
+ *
+ * Copyright 2015  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 2 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, see <http://www.gnu.org/licenses/>.
+ *
+ * Author: Marek Kasik <mkasik@redhat.com>
+ */
+
+#pragma once
+
+#include <glib-object.h>
+#include <gio/gio.h>
+
+G_BEGIN_DECLS
+
+#define PP_TYPE_PRINT_DEVICE (pp_print_device_get_type ())
+G_DECLARE_FINAL_TYPE (PpPrintDevice, pp_print_device, PP, PRINT_DEVICE, GObject)
+
+PpPrintDevice *pp_print_device_new                       (void);
+PpPrintDevice *pp_print_device_copy                      (PpPrintDevice *device);
+gchar         *pp_print_device_get_device_name           (PpPrintDevice *device);
+gchar         *pp_print_device_get_display_name          (PpPrintDevice *device);
+gchar         *pp_print_device_get_device_original_name  (PpPrintDevice *device);
+gchar         *pp_print_device_get_device_make_and_model (PpPrintDevice *device);
+gchar         *pp_print_device_get_device_location       (PpPrintDevice *device);
+gchar         *pp_print_device_get_device_info           (PpPrintDevice *device);
+gchar         *pp_print_device_get_device_uri            (PpPrintDevice *device);
+gchar         *pp_print_device_get_device_id             (PpPrintDevice *device);
+gchar         *pp_print_device_get_device_ppd            (PpPrintDevice *device);
+gchar         *pp_print_device_get_host_name             (PpPrintDevice *device);
+gint           pp_print_device_get_host_port             (PpPrintDevice *device);
+gboolean       pp_print_device_is_authenticated_server   (PpPrintDevice *device);
+gint           pp_print_device_get_acquisition_method    (PpPrintDevice *device);
+gboolean       pp_print_device_is_network_device         (PpPrintDevice *device);
+
+G_END_DECLS
diff --git a/panels/printers/pp-printer-entry.c b/panels/printers/pp-printer-entry.c
new file mode 100644
index 0000000..ba87004
--- /dev/null
+++ b/panels/printers/pp-printer-entry.c
@@ -0,0 +1,1022 @@
+/*
+ * Copyright 2017 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 2 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, see <http://www.gnu.org/licenses/>.
+ *
+ * Author: Felipe Borges <felipeborges@gnome.org>
+ */
+
+#include <config.h>
+
+#include "pp-printer-entry.h"
+#include <gtk/gtk.h>
+#include <glib/gi18n-lib.h>
+#include <glib/gstdio.h>
+
+#include "pp-details-dialog.h"
+#include "pp-maintenance-command.h"
+#include "pp-options-dialog.h"
+#include "pp-jobs-dialog.h"
+#include "pp-printer.h"
+#include "pp-utils.h"
+
+#define SUPPLY_BAR_HEIGHT 8
+
+typedef struct
+{
+  gchar *marker_names;
+  gchar *marker_levels;
+  gchar *marker_colors;
+  gchar *marker_types;
+} InkLevelData;
+
+struct _PpPrinterEntry
+{
+  GtkListBoxRow parent;
+
+  gchar    *printer_name;
+  gboolean  is_accepting_jobs;
+  gchar    *printer_make_and_model;
+  gchar    *printer_location;
+  gchar    *printer_hostname;
+  gboolean  is_authorized;
+  gint      printer_state;
+  InkLevelData *inklevel;
+
+  /* Maintenance commands */
+  PpMaintenanceCommand *clean_command;
+  GCancellable *check_clean_heads_cancellable;
+
+  /* Widgets */
+  GtkImage       *printer_icon;
+  GtkLabel       *printer_status;
+  GtkLabel       *printer_name_label;
+  GtkLabel       *printer_model_label;
+  GtkLabel       *printer_model;
+  GtkLabel       *printer_location_label;
+  GtkLabel       *printer_location_address_label;
+  GtkLabel       *printer_inklevel_label;
+  GtkFrame       *supply_frame;
+  GtkDrawingArea *supply_drawing_area;
+  GtkWidget      *show_jobs_dialog_button;
+  GtkWidget      *clean_heads_menuitem;
+  GtkCheckButton *printer_default_checkbutton;
+  GtkWidget      *remove_printer_menuitem;
+  GtkBox         *printer_error;
+  GtkLabel       *error_status;
+
+  /* Dialogs */
+  PpJobsDialog    *pp_jobs_dialog;
+
+  GCancellable *get_jobs_cancellable;
+};
+
+struct _PpPrinterEntryClass
+{
+  GtkListBoxRowClass parent_class;
+
+  void (*printer_changed) (PpPrinterEntry *printer_entry);
+  void (*printer_delete)  (PpPrinterEntry *printer_entry);
+  void (*printer_renamed) (PpPrinterEntry *printer_entry, const gchar *new_name);
+};
+
+G_DEFINE_TYPE (PpPrinterEntry, pp_printer_entry, GTK_TYPE_LIST_BOX_ROW)
+
+enum {
+  IS_DEFAULT_PRINTER,
+  PRINTER_DELETE,
+  PRINTER_RENAMED,
+  LAST_SIGNAL,
+};
+
+static guint signals[LAST_SIGNAL] = { 0 };
+
+static InkLevelData *
+ink_level_data_new (void)
+{
+  return g_slice_new0 (InkLevelData);
+}
+
+static void
+ink_level_data_free (InkLevelData *data)
+{
+  g_clear_pointer (&data->marker_names, g_free);
+  g_clear_pointer (&data->marker_levels, g_free);
+  g_clear_pointer (&data->marker_colors, g_free);
+  g_clear_pointer (&data->marker_types, g_free);
+  g_slice_free (InkLevelData, data);
+}
+
+static void
+pp_printer_entry_init (PpPrinterEntry *self)
+{
+  gtk_widget_init_template (GTK_WIDGET (self));
+  self->inklevel = ink_level_data_new ();
+}
+
+typedef struct {
+  gchar *color;
+  gchar *type;
+  gchar *name;
+  gint   level;
+} MarkerItem;
+
+static gint
+markers_cmp (gconstpointer a,
+             gconstpointer b)
+{
+  MarkerItem *x = (MarkerItem*) a;
+  MarkerItem *y = (MarkerItem*) b;
+
+  if (x->level < y->level)
+    return 1;
+  else if (x->level == y->level)
+    return 0;
+  else
+    return -1;
+}
+
+static gchar *
+sanitize_printer_model (const gchar *printer_make_and_model)
+{
+  gchar            *breakpoint = NULL, *tmp2 = NULL;
+  g_autofree gchar *tmp = NULL;
+  gchar             backup;
+  size_t            length = 0;
+  gchar            *forbidden[] = {
+    "foomatic",
+    ",",
+    "hpijs",
+    "hpcups",
+    "(recommended)",
+    "postscript (recommended)",
+    NULL };
+  int     i;
+
+  tmp = g_ascii_strdown (printer_make_and_model, -1);
+
+  for (i = 0; i < g_strv_length (forbidden); i++)
+    {
+      tmp2 = g_strrstr (tmp, forbidden[i]);
+      if (breakpoint == NULL ||
+         (tmp2 != NULL && tmp2 < breakpoint))
+           breakpoint = tmp2;
+    }
+
+  if (breakpoint)
+    {
+      backup = *breakpoint;
+      *breakpoint = '\0';
+      length = strlen (tmp);
+      *breakpoint = backup;
+
+      if (length > 0)
+        return g_strndup (printer_make_and_model, length);
+    }
+  else
+    return g_strdup (printer_make_and_model);
+
+  return NULL;
+}
+
+static gboolean
+supply_level_is_empty (PpPrinterEntry *self)
+{
+    return !((self->inklevel->marker_levels != NULL) &&
+             (self->inklevel->marker_colors != NULL) &&
+             (self->inklevel->marker_names != NULL) &&
+             (self->inklevel->marker_types != NULL));
+}
+
+/* To tone down the colors in the supply level bar
+ * we shade them by darkening the hue.
+ *
+ * Obs.: we don't know whether the color is already
+ * shaded.
+ *
+ */
+static void
+tone_down_color (GdkRGBA *color,
+                 gdouble  hue_ratio,
+                 gdouble  saturation_ratio,
+                 gdouble  value_ratio)
+{
+  gfloat h, s, v;
+
+  gtk_rgb_to_hsv (color->red, color->green, color->blue,
+                  &h, &s, &v);
+  gtk_hsv_to_rgb (h * hue_ratio, s * saturation_ratio, v * value_ratio,
+                  &color->red, &color->green, &color->blue);
+}
+
+static void
+supply_levels_draw_cb (GtkDrawingArea *drawing_area,
+                       cairo_t        *cr,
+                       int             width,
+                       int             height,
+                       gpointer        user_data)
+{
+  PpPrinterEntry         *self = PP_PRINTER_ENTRY (user_data);
+  GtkStyleContext        *context;
+  gboolean                is_empty = TRUE;
+  g_autofree gchar       *tooltip_text = NULL;
+  int                     i;
+
+  context = gtk_widget_get_style_context (GTK_WIDGET (self->supply_drawing_area));
+
+  gtk_render_background (context, cr, 0, 0, width, height);
+
+  if (!supply_level_is_empty (self))
+    {
+      GSList   *markers = NULL;
+      GSList   *tmp_list = NULL;
+      gchar   **marker_levelsv = NULL;
+      gchar   **marker_colorsv = NULL;
+      gchar   **marker_namesv = NULL;
+      gchar   **marker_typesv = NULL;
+
+      gtk_style_context_save (context);
+
+      marker_levelsv = g_strsplit (self->inklevel->marker_levels, ",", -1);
+      marker_colorsv = g_strsplit (self->inklevel->marker_colors, ",", -1);
+      marker_namesv = g_strsplit (self->inklevel->marker_names, ",", -1);
+      marker_typesv = g_strsplit (self->inklevel->marker_types, ",", -1);
+
+      if (g_strv_length (marker_levelsv) == g_strv_length (marker_colorsv) &&
+          g_strv_length (marker_colorsv) == g_strv_length (marker_namesv) &&
+          g_strv_length (marker_namesv) == g_strv_length (marker_typesv))
+        {
+          for (i = 0; i < g_strv_length (marker_levelsv); i++)
+            {
+              MarkerItem *marker;
+
+              if (g_strcmp0 (marker_typesv[i], "ink") == 0 ||
+                  g_strcmp0 (marker_typesv[i], "toner") == 0 ||
+                  g_strcmp0 (marker_typesv[i], "inkCartridge") == 0 ||
+                  g_strcmp0 (marker_typesv[i], "tonerCartridge") == 0)
+                {
+                  marker = g_new0 (MarkerItem, 1);
+                  marker->type = g_strdup (marker_typesv[i]);
+                  marker->name = g_strdup (marker_namesv[i]);
+                  marker->color = g_strdup (marker_colorsv[i]);
+                  marker->level = atoi (marker_levelsv[i]);
+
+                  markers = g_slist_prepend (markers, marker);
+                }
+            }
+
+            markers = g_slist_sort (markers, markers_cmp);
+
+            for (tmp_list = markers; tmp_list; tmp_list = tmp_list->next)
+              {
+                GdkRGBA color = {0.0, 0.0, 0.0, 1.0};
+                double  display_value;
+                int     value;
+
+                value = ((MarkerItem*) tmp_list->data)->level;
+
+                gdk_rgba_parse (&color, ((MarkerItem*) tmp_list->data)->color);
+                tone_down_color (&color, 1.0, 0.6, 0.9);
+
+                if (value > 0)
+                  {
+                    display_value = value / 100.0 * (width - 3.0);
+                    gdk_cairo_set_source_rgba (cr, &color);
+                    cairo_rectangle (cr, 2.0, 2.0, display_value, SUPPLY_BAR_HEIGHT);
+                    cairo_fill (cr);
+
+                    tone_down_color (&color, 1.0, 1.0, 0.85);
+                    gdk_cairo_set_source_rgba (cr, &color);
+                    cairo_set_line_width (cr, 1.0);
+                    cairo_rectangle (cr, 1.5, 1.5, display_value, SUPPLY_BAR_HEIGHT + 1);
+                    cairo_stroke (cr);
+
+                    is_empty = FALSE;
+                  }
+
+                if (tooltip_text)
+                  {
+                    g_autofree gchar *old_tooltip_text = g_steal_pointer (&tooltip_text);
+                    tooltip_text = g_strdup_printf ("%s\n%s",
+                                                    old_tooltip_text,
+                                                    ((MarkerItem*) tmp_list->data)->name);
+                  }
+                else
+                  tooltip_text = g_strdup_printf ("%s",
+                                                  ((MarkerItem*) tmp_list->data)->name);
+              }
+
+            gtk_render_frame (context, cr, 1, 1, width - 1, SUPPLY_BAR_HEIGHT);
+
+            for (tmp_list = markers; tmp_list; tmp_list = tmp_list->next)
+              {
+                g_free (((MarkerItem*) tmp_list->data)->name);
+                g_free (((MarkerItem*) tmp_list->data)->type);
+                g_free (((MarkerItem*) tmp_list->data)->color);
+              }
+            g_slist_free_full (markers, g_free);
+          }
+
+        gtk_style_context_restore (context);
+
+    if (tooltip_text)
+      {
+        gtk_widget_set_tooltip_text (GTK_WIDGET (self->supply_drawing_area), tooltip_text);
+      }
+    else
+      {
+        gtk_widget_set_tooltip_text (GTK_WIDGET (self->supply_drawing_area), NULL);
+        gtk_widget_set_has_tooltip (GTK_WIDGET (self->supply_drawing_area), FALSE);
+      }
+    }
+
+  gtk_widget_set_visible (GTK_WIDGET (self->printer_inklevel_label), !is_empty);
+  gtk_widget_set_visible (GTK_WIDGET (self->supply_frame), !is_empty);
+}
+
+static void
+on_printer_rename_cb (GObject      *source_object,
+                      GAsyncResult *result,
+                      gpointer      user_data)
+{
+  PpPrinterEntry *self = user_data;
+
+  if (!pp_printer_rename_finish (PP_PRINTER (source_object), result, NULL))
+    return;
+
+  g_signal_emit_by_name (self, "printer-renamed", pp_printer_get_name (PP_PRINTER (source_object)));
+}
+
+static void
+show_printer_details_response_cb (PpDetailsDialog *dialog,
+                                  gint             reponse,
+                                  PpPrinterEntry  *self)
+{
+  const gchar *new_name;
+  const gchar *new_location;
+
+  new_location = pp_details_dialog_get_printer_location (dialog);
+  if (g_strcmp0 (self->printer_location, new_location) != 0)
+    printer_set_location (self->printer_name, new_location);
+
+  new_name = pp_details_dialog_get_printer_name (dialog);
+  if (g_strcmp0 (self->printer_name, new_name) != 0 && printer_name_is_valid (new_name))
+    {
+      g_autoptr(PpPrinter) printer = pp_printer_new (self->printer_name);
+
+      pp_printer_rename_async (printer,
+                               new_name,
+                               NULL,
+                               on_printer_rename_cb,
+                               self);
+    }
+
+  g_signal_emit_by_name (self, "printer-changed");
+
+  gtk_window_destroy (GTK_WINDOW (dialog));
+}
+
+static void
+on_show_printer_details_dialog (GtkButton      *button,
+                                PpPrinterEntry *self)
+{
+  PpDetailsDialog *dialog = pp_details_dialog_new (self->printer_name,
+                                                   self->printer_location,
+                                                   self->printer_hostname,
+                                                   self->printer_make_and_model,
+                                                   self->is_authorized);
+
+  gtk_window_set_transient_for (GTK_WINDOW (dialog),
+                                GTK_WINDOW (gtk_widget_get_native (GTK_WIDGET (self))));
+
+  g_signal_connect (dialog, "response", G_CALLBACK (show_printer_details_response_cb), self);
+
+  gtk_window_present (GTK_WINDOW (dialog));
+}
+
+static void
+on_show_printer_options_dialog (GtkButton      *button,
+                                PpPrinterEntry *self)
+{
+  PpOptionsDialog *dialog;
+
+  dialog = pp_options_dialog_new (self->printer_name, self->is_authorized);
+
+  gtk_window_set_transient_for (GTK_WINDOW (dialog),
+                                GTK_WINDOW (gtk_widget_get_native (GTK_WIDGET (self))));
+
+  gtk_window_present (GTK_WINDOW (dialog));
+}
+
+static void
+set_as_default_printer (GtkCheckButton *button,
+                        PpPrinterEntry *self)
+{
+  printer_set_default (self->printer_name);
+
+  g_signal_emit_by_name (self, "printer-changed");
+}
+
+static void
+check_clean_heads_maintenance_command_cb (GObject      *source_object,
+                                          GAsyncResult *res,
+                                          gpointer      user_data)
+{
+  PpPrinterEntry       *self = user_data;
+  gboolean              is_supported = FALSE;
+  g_autoptr(GError)     error = NULL;
+
+  is_supported = pp_maintenance_command_is_supported_finish (PP_MAINTENANCE_COMMAND (source_object), res, &error);
+  if (error != NULL)
+    {
+      g_debug ("Could not check 'Clean' maintenance command: %s", error->message);
+      return;
+    }
+
+  if (is_supported)
+    {
+      gtk_widget_show (GTK_WIDGET (self->clean_heads_menuitem));
+    }
+}
+
+static void
+check_clean_heads_maintenance_command (PpPrinterEntry *self)
+{
+  if (self->clean_command == NULL)
+    return;
+
+  g_object_ref (self->clean_command);
+  self->check_clean_heads_cancellable = g_cancellable_new ();
+
+  pp_maintenance_command_is_supported_async (self->clean_command,
+                                             self->check_clean_heads_cancellable,
+                                             check_clean_heads_maintenance_command_cb,
+                                             self);
+}
+
+static void
+clean_heads_maintenance_command_cb (GObject      *source_object,
+                                    GAsyncResult *res,
+                                    gpointer      user_data)
+{
+  PpPrinterEntry *self = user_data;
+  g_autoptr(GError) error = NULL;
+
+  if (!pp_maintenance_command_execute_finish (PP_MAINTENANCE_COMMAND (source_object), res, &error))
+    g_warning ("Error cleaning print heads for %s: %s", self->printer_name, error->message);
+}
+
+static void
+clean_heads (GtkButton *button,
+             PpPrinterEntry *self)
+{
+  if (self->clean_command == NULL)
+    return;
+
+  g_object_ref (self->clean_command);
+  pp_maintenance_command_execute_async (self->clean_command,
+                                        NULL,
+                                        clean_heads_maintenance_command_cb,
+                                        self);
+}
+
+static void
+remove_printer (GtkButton      *button,
+                PpPrinterEntry *self)
+{
+  g_signal_emit_by_name (self, "printer-delete");
+}
+
+static void
+get_jobs_cb (GObject      *source_object,
+             GAsyncResult *result,
+             gpointer      user_data)
+{
+  PpPrinterEntry      *self = user_data;
+  g_autoptr(GError)    error = NULL;
+  g_autoptr(GPtrArray) jobs = NULL;
+  g_autofree gchar    *button_label = NULL;
+
+  jobs = pp_printer_get_jobs_finish (PP_PRINTER (source_object), result, &error);
+
+  if (error != NULL)
+    {
+      if (!g_error_matches (error, G_IO_ERROR, G_IO_ERROR_CANCELLED))
+        {
+          g_warning ("Could not get jobs: %s", error->message);
+        }
+
+      return;
+    }
+
+  if (jobs->len == 0)
+    {
+      /* Translators: This is the label of the button that opens the Jobs Dialog. */
+      button_label = g_strdup (_("No Active Jobs"));
+    }
+  else
+    {
+      /* Translators: This is the label of the button that opens the Jobs Dialog. */
+      button_label = g_strdup_printf (ngettext ("%u Job", "%u Jobs", jobs->len), jobs->len);
+    }
+
+  gtk_button_set_label (GTK_BUTTON (self->show_jobs_dialog_button), button_label);
+  gtk_widget_set_sensitive (self->show_jobs_dialog_button, jobs->len > 0);
+
+  if (self->pp_jobs_dialog != NULL)
+    {
+      pp_jobs_dialog_update (self->pp_jobs_dialog);
+    }
+
+  g_clear_object (&self->get_jobs_cancellable);
+}
+
+void
+pp_printer_entry_update_jobs_count (PpPrinterEntry *self)
+{
+  g_autoptr(PpPrinter) printer = NULL;
+
+  g_cancellable_cancel (self->get_jobs_cancellable);
+  g_clear_object (&self->get_jobs_cancellable);
+
+  self->get_jobs_cancellable = g_cancellable_new ();
+
+  printer = pp_printer_new (self->printer_name);
+  pp_printer_get_jobs_async (printer,
+                             TRUE,
+                             CUPS_WHICHJOBS_ACTIVE,
+                             self->get_jobs_cancellable,
+                             get_jobs_cb,
+                             self);
+}
+
+static void
+jobs_dialog_response_cb (GtkDialog  *dialog,
+                         gint        response_id,
+                         gpointer    user_data)
+{
+  PpPrinterEntry *self = (PpPrinterEntry*) user_data;
+
+  if (self->pp_jobs_dialog != NULL)
+    {
+      gtk_window_destroy (GTK_WINDOW (self->pp_jobs_dialog));
+      self->pp_jobs_dialog = NULL;
+    }
+}
+
+void
+pp_printer_entry_show_jobs_dialog (PpPrinterEntry *self)
+{
+  if (self->pp_jobs_dialog == NULL)
+    {
+      self->pp_jobs_dialog = pp_jobs_dialog_new (self->printer_name);
+      g_signal_connect_object (self->pp_jobs_dialog, "response", G_CALLBACK (jobs_dialog_response_cb), self, 0);
+      gtk_window_set_transient_for (GTK_WINDOW (self->pp_jobs_dialog), GTK_WINDOW (gtk_widget_get_native (GTK_WIDGET (self))));
+      gtk_window_present (GTK_WINDOW (self->pp_jobs_dialog));
+    }
+}
+
+void
+pp_printer_entry_authenticate_jobs (PpPrinterEntry *self)
+{
+  pp_printer_entry_show_jobs_dialog (self);
+  pp_jobs_dialog_authenticate_jobs (self->pp_jobs_dialog);
+}
+
+static void
+show_jobs_dialog (GtkButton *button,
+                  gpointer   user_data)
+{
+  pp_printer_entry_show_jobs_dialog (PP_PRINTER_ENTRY (user_data));
+}
+
+enum
+{
+  PRINTER_READY = 3,
+  PRINTER_PROCESSING,
+  PRINTER_STOPPED
+};
+
+static void
+restart_printer (GtkButton      *button,
+                 PpPrinterEntry *self)
+{
+  if (self->printer_state == PRINTER_STOPPED)
+    printer_set_enabled (self->printer_name, TRUE);
+
+  if (!self->is_accepting_jobs)
+    printer_set_accepting_jobs (self->printer_name, TRUE, NULL);
+
+  g_signal_emit_by_name (self, "printer-changed");
+}
+
+GSList *
+pp_printer_entry_get_size_group_widgets (PpPrinterEntry *self)
+{
+  GSList *widgets = NULL;
+
+  widgets = g_slist_prepend (widgets, self->printer_icon);
+  widgets = g_slist_prepend (widgets, self->printer_location_label);
+  widgets = g_slist_prepend (widgets, self->printer_model_label);
+  widgets = g_slist_prepend (widgets, self->printer_inklevel_label);
+
+  return widgets;
+}
+
+PpPrinterEntry *
+pp_printer_entry_new (cups_dest_t  printer,
+                      gboolean     is_authorized)
+{
+  PpPrinterEntry *self;
+
+  self = g_object_new (PP_PRINTER_ENTRY_TYPE, NULL);
+
+  self->printer_name = g_strdup (printer.name);
+
+  self->clean_command = pp_maintenance_command_new (self->printer_name,
+                                                    "Clean",
+                                                    "all",
+                                                    /* Translators: Name of job which makes printer to clean its heads */
+                                                    _("Clean print heads"));
+  check_clean_heads_maintenance_command (self);
+
+  gtk_drawing_area_set_draw_func (self->supply_drawing_area,
+                                  supply_levels_draw_cb,
+                                  self,
+                                  NULL);
+
+  pp_printer_entry_update (self, printer, is_authorized);
+
+  return self;
+}
+
+const gchar *
+pp_printer_entry_get_name (PpPrinterEntry *self)
+{
+  g_return_val_if_fail (PP_IS_PRINTER_ENTRY (self), NULL);
+  return self->printer_name;
+}
+
+const gchar *
+pp_printer_entry_get_location (PpPrinterEntry *self)
+{
+  g_return_val_if_fail (PP_IS_PRINTER_ENTRY (self), NULL);
+  return self->printer_location;
+}
+
+void
+pp_printer_entry_update (PpPrinterEntry *self,
+                         cups_dest_t     printer,
+                         gboolean        is_authorized)
+{
+  cups_ptype_t      printer_type = 0;
+  gboolean          is_accepting_jobs = TRUE;
+  gboolean          ink_supply_is_empty;
+  g_autofree gchar *instance = NULL;
+  const gchar      *printer_uri = NULL;
+  const gchar      *device_uri = NULL;
+  const gchar      *location = NULL;
+  g_autofree gchar *printer_icon_name = NULL;
+  const gchar      *printer_make_and_model = NULL;
+  const gchar      *reason = NULL;
+  gchar           **printer_reasons = NULL;
+  g_autofree gchar *status = NULL;
+  g_autofree gchar *printer_status = NULL;
+  int               i, j;
+  static const char * const reasons[] =
+    {
+      "toner-low",
+      "toner-empty",
+      "developer-low",
+      "developer-empty",
+      "marker-supply-low",
+      "marker-supply-empty",
+      "cover-open",
+      "door-open",
+      "media-low",
+      "media-empty",
+      "offline",
+      "paused",
+      "marker-waste-almost-full",
+      "marker-waste-full",
+      "opc-near-eol",
+      "opc-life-over"
+    };
+  static const char * statuses[] =
+    {
+      /* Translators: The printer is low on toner */
+      N_("Low on toner"),
+      /* Translators: The printer has no toner left */
+      N_("Out of toner"),
+      /* Translators: "Developer" is a chemical for photo development,
+       * http://en.wikipedia.org/wiki/Photographic_developer */
+      N_("Low on developer"),
+      /* Translators: "Developer" is a chemical for photo development,
+       * http://en.wikipedia.org/wiki/Photographic_developer */
+      N_("Out of developer"),
+      /* Translators: "marker" is one color bin of the printer */
+      N_("Low on a marker supply"),
+      /* Translators: "marker" is one color bin of the printer */
+      N_("Out of a marker supply"),
+      /* Translators: One or more covers on the printer are open */
+      N_("Open cover"),
+      /* Translators: One or more doors on the printer are open */
+      N_("Open door"),
+      /* Translators: At least one input tray is low on media */
+      N_("Low on paper"),
+      /* Translators: At least one input tray is empty */
+      N_("Out of paper"),
+      /* Translators: The printer is offline */
+      NC_("printer state", "Offline"),
+      /* Translators: Someone has stopped the Printer */
+      NC_("printer state", "Stopped"),
+      /* Translators: The printer marker supply waste receptacle is almost full */
+      N_("Waste receptacle almost full"),
+      /* Translators: The printer marker supply waste receptacle is full */
+      N_("Waste receptacle full"),
+      /* Translators: Optical photo conductors are used in laser printers */
+      N_("The optical photo conductor is near end of life"),
+      /* Translators: Optical photo conductors are used in laser printers */
+      N_("The optical photo conductor is no longer functioning")
+    };
+
+  if (printer.instance)
+    {
+      instance = g_strdup_printf ("%s / %s", printer.name, printer.instance);
+    }
+  else
+    {
+      instance = g_strdup (printer.name);
+    }
+
+  self->printer_state = PRINTER_READY;
+
+  for (i = 0; i < printer.num_options; i++)
+    {
+      if (g_strcmp0 (printer.options[i].name, "device-uri") == 0)
+        device_uri = printer.options[i].value;
+      else if (g_strcmp0 (printer.options[i].name, "printer-uri-supported") == 0)
+        printer_uri = printer.options[i].value;
+      else if (g_strcmp0 (printer.options[i].name, "printer-type") == 0)
+        printer_type = atoi (printer.options[i].value);
+      else if (g_strcmp0 (printer.options[i].name, "printer-location") == 0)
+        location = printer.options[i].value;
+      else if (g_strcmp0 (printer.options[i].name, "printer-state-reasons") == 0)
+        reason = printer.options[i].value;
+      else if (g_strcmp0 (printer.options[i].name, "marker-names") == 0)
+        {
+          g_free (self->inklevel->marker_names);
+          self->inklevel->marker_names = g_strcompress (g_strdup (printer.options[i].value));
+        }
+      else if (g_strcmp0 (printer.options[i].name, "marker-levels") == 0)
+        {
+          g_free (self->inklevel->marker_levels);
+          self->inklevel->marker_levels = g_strdup (printer.options[i].value);
+        }
+      else if (g_strcmp0 (printer.options[i].name, "marker-colors") == 0)
+        {
+          g_free (self->inklevel->marker_colors);
+          self->inklevel->marker_colors = g_strdup (printer.options[i].value);
+        }
+      else if (g_strcmp0 (printer.options[i].name, "marker-types") == 0)
+        {
+          g_free (self->inklevel->marker_types);
+          self->inklevel->marker_types = g_strdup (printer.options[i].value);
+        }
+      else if (g_strcmp0 (printer.options[i].name, "printer-make-and-model") == 0)
+        printer_make_and_model = printer.options[i].value;
+      else if (g_strcmp0 (printer.options[i].name, "printer-state") == 0)
+        self->printer_state = atoi (printer.options[i].value);
+      else if (g_strcmp0 (printer.options[i].name, "printer-is-accepting-jobs") == 0)
+        {
+          if (g_strcmp0 (printer.options[i].value, "true") == 0)
+            is_accepting_jobs = TRUE;
+          else
+            is_accepting_jobs = FALSE;
+        }
+    }
+
+  /* Find the first of the most severe reasons
+   * and show it in the status field
+   */
+  if (reason && !g_str_equal (reason, "none"))
+    {
+      int errors = 0, warnings = 0, reports = 0;
+      int error_index = -1, warning_index = -1, report_index = -1;
+
+      printer_reasons = g_strsplit (reason, ",", -1);
+      for (i = 0; i < g_strv_length (printer_reasons); i++)
+        {
+          for (j = 0; j < G_N_ELEMENTS (reasons); j++)
+            if (strncmp (printer_reasons[i], reasons[j], strlen (reasons[j])) == 0)
+                {
+                  if (g_str_has_suffix (printer_reasons[i], "-report"))
+                    {
+                      if (reports == 0)
+                        report_index = j;
+                      reports++;
+                    }
+                  else if (g_str_has_suffix (printer_reasons[i], "-warning"))
+                    {
+                      if (warnings == 0)
+                        warning_index = j;
+                      warnings++;
+                    }
+                  else
+                    {
+                      if (errors == 0)
+                        error_index = j;
+                      errors++;
+                    }
+                }
+        }
+      g_strfreev (printer_reasons);
+
+      if (error_index >= 0)
+        status = g_strdup (_(statuses[error_index]));
+      else if (warning_index >= 0)
+        status = g_strdup (_(statuses[warning_index]));
+      else if (report_index >= 0)
+        status = g_strdup (_(statuses[report_index]));
+    }
+
+  if ((self->printer_state == PRINTER_STOPPED || !is_accepting_jobs) &&
+      status != NULL && status[0] != '\0')
+    {
+      gtk_label_set_label (self->error_status, status);
+      gtk_widget_set_visible (GTK_WIDGET (self->printer_error), TRUE);
+    }
+  else
+    {
+      gtk_label_set_label (self->error_status, "");
+      gtk_widget_set_visible (GTK_WIDGET (self->printer_error), FALSE);
+    }
+
+  switch (self->printer_state)
+    {
+      case PRINTER_READY:
+        if (is_accepting_jobs)
+          {
+            /* Translators: Printer's state (can start new job without waiting) */
+            printer_status = g_strdup ( C_("printer state", "Ready"));
+          }
+        else
+          {
+            /* Translators: Printer's state (printer is ready but doesn't accept new jobs) */
+            printer_status = g_strdup ( C_("printer state", "Does not accept jobs"));
+          }
+        break;
+      case PRINTER_PROCESSING:
+        /* Translators: Printer's state (jobs are processing) */
+        printer_status = g_strdup ( C_("printer state", "Processing"));
+        break;
+      case PRINTER_STOPPED:
+        /* Translators: Printer's state (no jobs can be processed) */
+        printer_status = g_strdup ( C_("printer state", "Stopped"));
+        break;
+    }
+
+  if (printer_is_local (printer_type, device_uri))
+    printer_icon_name = g_strdup ("printer");
+  else
+    printer_icon_name = g_strdup ("printer-network");
+
+  g_free (self->printer_location);
+  self->printer_location = g_strdup (location);
+
+  self->is_accepting_jobs = is_accepting_jobs;
+  self->is_authorized = is_authorized;
+
+  g_free (self->printer_hostname);
+  self->printer_hostname = printer_get_hostname (printer_type, device_uri, printer_uri);
+
+  gtk_image_set_from_icon_name (self->printer_icon, printer_icon_name);
+  gtk_label_set_text (self->printer_status, printer_status);
+  gtk_label_set_text (self->printer_name_label, instance);
+  g_signal_handlers_block_by_func (self->printer_default_checkbutton, set_as_default_printer, self);
+  gtk_check_button_set_active (self->printer_default_checkbutton, printer.is_default);
+  g_signal_handlers_unblock_by_func (self->printer_default_checkbutton, set_as_default_printer, self);
+
+  self->printer_make_and_model = sanitize_printer_model (printer_make_and_model);
+
+  if (self->printer_make_and_model == NULL || self->printer_make_and_model[0] == '\0')
+    {
+      gtk_widget_hide (GTK_WIDGET (self->printer_model_label));
+      gtk_widget_hide (GTK_WIDGET (self->printer_model));
+    }
+  else
+    {
+      gtk_label_set_text (self->printer_model, self->printer_make_and_model);
+    }
+
+  if (location != NULL && location[0] == '\0')
+    {
+      gtk_widget_hide (GTK_WIDGET (self->printer_location_label));
+      gtk_widget_hide (GTK_WIDGET (self->printer_location_address_label));
+    }
+  else
+    {
+      gtk_label_set_text (self->printer_location_address_label, location);
+    }
+
+  ink_supply_is_empty = supply_level_is_empty (self);
+  gtk_widget_set_visible (GTK_WIDGET (self->printer_inklevel_label), !ink_supply_is_empty);
+  gtk_widget_set_visible (GTK_WIDGET (self->supply_frame), !ink_supply_is_empty);
+
+  pp_printer_entry_update_jobs_count (self);
+
+  gtk_widget_set_sensitive (GTK_WIDGET (self->printer_default_checkbutton), self->is_authorized);
+  gtk_widget_set_sensitive (GTK_WIDGET (self->remove_printer_menuitem), self->is_authorized);
+}
+
+static void
+pp_printer_entry_dispose (GObject *object)
+{
+  PpPrinterEntry *self = PP_PRINTER_ENTRY (object);
+
+  g_cancellable_cancel (self->get_jobs_cancellable);
+  g_cancellable_cancel (self->check_clean_heads_cancellable);
+
+  g_clear_pointer (&self->printer_name, g_free);
+  g_clear_pointer (&self->printer_location, g_free);
+  g_clear_pointer (&self->printer_make_and_model, g_free);
+  g_clear_pointer (&self->printer_hostname, g_free);
+  g_clear_pointer (&self->inklevel, ink_level_data_free);
+  g_clear_object (&self->get_jobs_cancellable);
+  g_clear_object (&self->check_clean_heads_cancellable);
+  g_clear_object (&self->clean_command);
+
+  G_OBJECT_CLASS (pp_printer_entry_parent_class)->dispose (object);
+}
+
+static void
+pp_printer_entry_class_init (PpPrinterEntryClass *klass)
+{
+  GtkWidgetClass *widget_class = GTK_WIDGET_CLASS (klass);
+  GObjectClass   *object_class = G_OBJECT_CLASS (klass);
+
+  gtk_widget_class_set_template_from_resource (widget_class, "/org/gnome/control-center/printers/printer-entry.ui");
+
+  gtk_widget_class_bind_template_child (widget_class, PpPrinterEntry, printer_icon);
+  gtk_widget_class_bind_template_child (widget_class, PpPrinterEntry, printer_name_label);
+  gtk_widget_class_bind_template_child (widget_class, PpPrinterEntry, printer_status);
+  gtk_widget_class_bind_template_child (widget_class, PpPrinterEntry, printer_model_label);
+  gtk_widget_class_bind_template_child (widget_class, PpPrinterEntry, printer_model);
+  gtk_widget_class_bind_template_child (widget_class, PpPrinterEntry, printer_location_label);
+  gtk_widget_class_bind_template_child (widget_class, PpPrinterEntry, printer_location_address_label);
+  gtk_widget_class_bind_template_child (widget_class, PpPrinterEntry, printer_inklevel_label);
+  gtk_widget_class_bind_template_child (widget_class, PpPrinterEntry, supply_frame);
+  gtk_widget_class_bind_template_child (widget_class, PpPrinterEntry, supply_drawing_area);
+  gtk_widget_class_bind_template_child (widget_class, PpPrinterEntry, printer_default_checkbutton);
+  gtk_widget_class_bind_template_child (widget_class, PpPrinterEntry, show_jobs_dialog_button);
+  gtk_widget_class_bind_template_child (widget_class, PpPrinterEntry, clean_heads_menuitem);
+  gtk_widget_class_bind_template_child (widget_class, PpPrinterEntry, remove_printer_menuitem);
+  gtk_widget_class_bind_template_child (widget_class, PpPrinterEntry, error_status);
+  gtk_widget_class_bind_template_child (widget_class, PpPrinterEntry, printer_error);
+
+  gtk_widget_class_bind_template_callback (widget_class, on_show_printer_details_dialog);
+  gtk_widget_class_bind_template_callback (widget_class, on_show_printer_options_dialog);
+  gtk_widget_class_bind_template_callback (widget_class, set_as_default_printer);
+  gtk_widget_class_bind_template_callback (widget_class, clean_heads);
+  gtk_widget_class_bind_template_callback (widget_class, remove_printer);
+  gtk_widget_class_bind_template_callback (widget_class, show_jobs_dialog);
+  gtk_widget_class_bind_template_callback (widget_class, restart_printer);
+
+  object_class->dispose = pp_printer_entry_dispose;
+
+  signals[IS_DEFAULT_PRINTER] =
+    g_signal_new ("printer-changed",
+                  G_TYPE_FROM_CLASS (klass),
+                  G_SIGNAL_RUN_LAST,
+                  0,
+                  NULL, NULL, NULL,
+                  G_TYPE_NONE, 0);
+
+  signals[PRINTER_DELETE] =
+    g_signal_new ("printer-delete",
+                  G_TYPE_FROM_CLASS (klass),
+                  G_SIGNAL_RUN_LAST,
+                  0,
+                  NULL, NULL, NULL,
+                  G_TYPE_NONE, 0);
+
+  signals[PRINTER_RENAMED] =
+    g_signal_new ("printer-renamed",
+                  G_TYPE_FROM_CLASS (klass),
+                  G_SIGNAL_RUN_LAST,
+                  0,
+                  NULL, NULL, NULL,
+                  G_TYPE_NONE, 1,
+                  G_TYPE_STRING);
+}
diff --git a/panels/printers/pp-printer-entry.h b/panels/printers/pp-printer-entry.h
new file mode 100644
index 0000000..1c6b3dc
--- /dev/null
+++ b/panels/printers/pp-printer-entry.h
@@ -0,0 +1,45 @@
+/*
+ * Copyright 2017 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 2 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, see <http://www.gnu.org/licenses/>.
+ *
+ * Author: Felipe Borges <felipeborges@gnome.org>
+ */
+
+#pragma once
+
+#include <gtk/gtk.h>
+#include <cups/cups.h>
+
+#define PP_PRINTER_ENTRY_TYPE (pp_printer_entry_get_type ())
+G_DECLARE_FINAL_TYPE (PpPrinterEntry, pp_printer_entry, PP, PRINTER_ENTRY, GtkListBoxRow)
+
+PpPrinterEntry *pp_printer_entry_new  (cups_dest_t printer,
+                                       gboolean    is_authorized);
+
+const gchar    *pp_printer_entry_get_name (PpPrinterEntry *self);
+
+const gchar    *pp_printer_entry_get_location (PpPrinterEntry *self);
+
+void            pp_printer_entry_update_jobs_count (PpPrinterEntry *self);
+
+GSList         *pp_printer_entry_get_size_group_widgets (PpPrinterEntry *self);
+
+void            pp_printer_entry_show_jobs_dialog (PpPrinterEntry *self);
+
+void            pp_printer_entry_authenticate_jobs (PpPrinterEntry *self);
+
+void            pp_printer_entry_update (PpPrinterEntry *self,
+                                         cups_dest_t     printer,
+                                         gboolean        is_authorized);
diff --git a/panels/printers/pp-printer.c b/panels/printers/pp-printer.c
new file mode 100644
index 0000000..76d0bfc
--- /dev/null
+++ b/panels/printers/pp-printer.c
@@ -0,0 +1,562 @@
+/*
+ * Copyright (C) 2016 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 2 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, see <http://www.gnu.org/licenses/>.
+ *
+ * Authors: Martin Hatina <mhatina@redhat.com>
+ *          Marek Kasik <mkasik@redhat.com>
+ */
+
+#include "pp-printer.h"
+
+#include "pp-job.h"
+
+#if (CUPS_VERSION_MAJOR == 1) && (CUPS_VERSION_MINOR <= 6)
+#define IPP_STATE_IDLE IPP_IDLE
+#endif
+
+struct _PpPrinter
+{
+  GObject  parent_instance;
+  gchar   *printer_name;
+};
+
+G_DEFINE_TYPE (PpPrinter, pp_printer, G_TYPE_OBJECT)
+
+static void
+pp_printer_dispose (GObject *object)
+{
+  PpPrinter *self = PP_PRINTER (object);
+
+  g_clear_pointer (&self->printer_name, g_free);
+
+  G_OBJECT_CLASS (pp_printer_parent_class)->dispose (object);
+}
+
+static void
+pp_printer_class_init (PpPrinterClass *klass)
+{
+  GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
+
+  gobject_class->dispose = pp_printer_dispose;
+}
+
+static void
+pp_printer_init (PpPrinter *self)
+{
+}
+
+PpPrinter *
+pp_printer_new (const gchar *name)
+{
+  PpPrinter *self = g_object_new (PP_TYPE_PRINTER, NULL);
+
+  self->printer_name = g_strdup (name);
+
+  return self;
+}
+
+const gchar *
+pp_printer_get_name (PpPrinter *self)
+{
+  g_return_val_if_fail (PP_IS_PRINTER (self), NULL);
+  return self->printer_name;
+}
+
+static void
+printer_rename_thread (GTask        *task,
+                       gpointer      source_object,
+                       gpointer      task_data,
+                       GCancellable *cancellable)
+{
+  PpPrinter        *self = PP_PRINTER (source_object);
+  gboolean          result;
+  const gchar      *new_printer_name = task_data;
+
+  result = printer_rename (self->printer_name, new_printer_name);
+
+  if (result)
+    {
+      g_free (self->printer_name);
+      self->printer_name = g_strdup (new_printer_name);
+    }
+
+  g_task_return_boolean (task, result);
+}
+
+static void
+printer_rename_dbus_cb (GObject      *source_object,
+                        GAsyncResult *res,
+                        gpointer      user_data)
+{
+  PpPrinter          *self;
+  g_autoptr(GVariant) output = NULL;
+  gboolean            result = FALSE;
+  g_autoptr(GError)   error = NULL;
+  g_autoptr(GTask)    task = user_data;
+
+  output = g_dbus_connection_call_finish (G_DBUS_CONNECTION (source_object),
+                                          res,
+                                          &error);
+
+  if (output != NULL)
+    {
+      const gchar *ret_error;
+
+      self = g_task_get_source_object (task);
+
+      g_variant_get (output, "(&s)", &ret_error);
+      if (ret_error[0] != '\0')
+        {
+          g_warning ("cups-pk-helper: renaming of printer %s failed: %s", self->printer_name, ret_error);
+        }
+      else
+        {
+          result = TRUE;
+          g_free (self->printer_name);
+          self->printer_name = g_strdup (g_task_get_task_data (task));
+        }
+
+      g_task_return_boolean (task, result);
+    }
+  else
+    {
+      if (error->domain == G_DBUS_ERROR &&
+          (error->code == G_DBUS_ERROR_SERVICE_UNKNOWN ||
+           error->code == G_DBUS_ERROR_UNKNOWN_METHOD))
+        {
+          g_warning ("Update cups-pk-helper to at least 0.2.6 please to be able to use PrinterRename method.");
+
+          g_task_run_in_thread (task, printer_rename_thread);
+        }
+      else
+        {
+          g_task_return_boolean (task, FALSE);
+        }
+    }
+}
+
+static void
+get_bus_cb (GObject      *source_object,
+            GAsyncResult *res,
+            gpointer      user_data)
+{
+  PpPrinter *self;
+  GDBusConnection  *bus;
+  g_autoptr(GError) error = NULL;
+  g_autoptr(GTask)  task = user_data;
+
+  bus = g_bus_get_finish (res, &error);
+  if (bus != NULL)
+    {
+      self = g_task_get_source_object (task);
+      g_dbus_connection_call (bus,
+                              MECHANISM_BUS,
+                              "/",
+                              MECHANISM_BUS,
+                              "PrinterRename",
+                              g_variant_new ("(ss)",
+                                             self->printer_name,
+                                             g_task_get_task_data (task)),
+                              G_VARIANT_TYPE ("(s)"),
+                              G_DBUS_CALL_FLAGS_NONE,
+                              -1,
+                              g_task_get_cancellable (task),
+                              printer_rename_dbus_cb,
+                              task);
+      g_steal_pointer (&task);
+    }
+  else
+    {
+      g_warning ("Failed to get system bus: %s", error->message);
+      g_task_return_boolean (task, FALSE);
+    }
+}
+
+void
+pp_printer_rename_async (PpPrinter           *self,
+                         const gchar         *new_printer_name,
+                         GCancellable        *cancellable,
+                         GAsyncReadyCallback  callback,
+                         gpointer             user_data)
+{
+  GTask *task;
+
+  g_return_if_fail (new_printer_name != NULL);
+
+  task = g_task_new (G_OBJECT (self), cancellable, callback, user_data);
+  g_task_set_task_data (task, g_strdup (new_printer_name), g_free);
+
+  g_bus_get (G_BUS_TYPE_SYSTEM,
+             cancellable,
+             get_bus_cb,
+             task);
+}
+
+gboolean
+pp_printer_rename_finish (PpPrinter     *self,
+                          GAsyncResult  *res,
+                          GError       **error)
+{
+  g_return_val_if_fail (g_task_is_valid (res, self), FALSE);
+
+  return g_task_propagate_boolean (G_TASK (res), error);
+}
+
+typedef struct
+{
+  gboolean  myjobs;
+  gint      which_jobs;
+} GetJobsData;
+
+static void
+get_jobs_thread (GTask        *task,
+                 gpointer      source_object,
+                 gpointer      task_data,
+                 GCancellable *cancellable)
+{
+  ipp_attribute_t  *attr = NULL;
+  static gchar     *printer_attributes[] = { "auth-info-required" };
+  GetJobsData      *get_jobs_data = task_data;
+  cups_job_t       *jobs = NULL;
+  PpPrinter        *self = PP_PRINTER (source_object);
+  gboolean          auth_info_is_required;
+  PpJob            *job;
+  ipp_t            *job_request;
+  ipp_t            *job_response;
+  ipp_t            *printer_request;
+  ipp_t            *printer_response;
+  gchar           **auth_info_required = NULL;
+  g_autofree gchar *printer_name = NULL;
+  g_autoptr(GPtrArray) array = NULL;
+  gint              num_jobs;
+  gint              i, j;
+
+  num_jobs = cupsGetJobs (&jobs,
+                          self->printer_name,
+                          get_jobs_data->myjobs ? 1 : 0,
+                          get_jobs_data->which_jobs);
+
+  array = g_ptr_array_new_with_free_func (g_object_unref);
+  for (i = 0; i < num_jobs; i++)
+    {
+      auth_info_is_required = FALSE;
+      if (jobs[i].state == IPP_JOB_HELD)
+        {
+          g_autofree gchar *job_uri = g_strdup_printf ("ipp://localhost/jobs/%d", jobs[i].id);
+
+          job_request = ippNewRequest (IPP_GET_JOB_ATTRIBUTES);
+          ippAddString (job_request, IPP_TAG_OPERATION, IPP_TAG_URI,
+                        "job-uri", NULL, job_uri);
+          ippAddString (job_request, IPP_TAG_OPERATION, IPP_TAG_NAME,
+                        "requesting-user-name", NULL, cupsUser ());
+          ippAddString (job_request, IPP_TAG_OPERATION, IPP_TAG_KEYWORD,
+                        "requested-attributes", NULL, "job-hold-until");
+          job_response = cupsDoRequest (CUPS_HTTP_DEFAULT, job_request, "/");
+
+          if (job_response != NULL)
+            {
+              attr = ippFindAttribute (job_response, "job-hold-until", IPP_TAG_ZERO);
+              if (attr != NULL && g_strcmp0 (ippGetString (attr, 0, NULL), "auth-info-required") == 0)
+                {
+                  auth_info_is_required = TRUE;
+
+                  if (auth_info_required == NULL)
+                    {
+                      g_autofree gchar *printer_uri = g_strdup_printf ("ipp://localhost/printers/%s", self->printer_name);
+
+                      printer_request = ippNewRequest (IPP_GET_PRINTER_ATTRIBUTES);
+                      ippAddString (printer_request, IPP_TAG_OPERATION, IPP_TAG_URI,
+                                    "printer-uri", NULL, printer_uri);
+                      ippAddString (printer_request, IPP_TAG_OPERATION, IPP_TAG_NAME,
+                                    "requesting-user-name", NULL, cupsUser ());
+                      ippAddStrings (printer_request, IPP_TAG_OPERATION, IPP_TAG_KEYWORD,
+                                     "requested-attributes", 1, NULL, (const char **) printer_attributes);
+                      printer_response = cupsDoRequest (CUPS_HTTP_DEFAULT, printer_request, "/");
+
+                      if (printer_response != NULL)
+                        {
+                          attr = ippFindAttribute (printer_response, "auth-info-required", IPP_TAG_ZERO);
+                          if (attr != NULL)
+                            {
+                              auth_info_required = g_new0 (gchar *, ippGetCount (attr) + 1);
+                              for (j = 0; j < ippGetCount (attr); j++)
+                                auth_info_required[j] = g_strdup (ippGetString (attr, j, NULL));
+                            }
+
+                          ippDelete (printer_response);
+                        }
+                    }
+                }
+
+              ippDelete (job_response);
+            }
+        }
+
+      job = pp_job_new (jobs[i].id, jobs[i].title, jobs[i].state, jobs[i].priority, auth_info_is_required ? auth_info_required : NULL);
+      g_ptr_array_add (array, job);
+    }
+
+  g_strfreev (auth_info_required);
+  cupsFreeJobs (num_jobs, jobs);
+
+  if (g_task_set_return_on_cancel (task, FALSE))
+    {
+      g_task_return_pointer (task, g_steal_pointer (&array), (GDestroyNotify) g_ptr_array_unref);
+    }
+}
+
+void
+pp_printer_get_jobs_async (PpPrinter           *self,
+                           gboolean             myjobs,
+                           gint                 which_jobs,
+                           GCancellable        *cancellable,
+                           GAsyncReadyCallback  callback,
+                           gpointer             user_data)
+{
+  GetJobsData *get_jobs_data;
+  g_autoptr(GTask) task = NULL;
+
+  get_jobs_data = g_new (GetJobsData, 1);
+  get_jobs_data->myjobs = myjobs;
+  get_jobs_data->which_jobs = which_jobs;
+
+  task = g_task_new (G_OBJECT (self), cancellable, callback, user_data);
+  g_task_set_task_data (task, get_jobs_data, g_free);
+  g_task_set_return_on_cancel (task, TRUE);
+  g_task_run_in_thread (task, get_jobs_thread);
+}
+
+GPtrArray *
+pp_printer_get_jobs_finish (PpPrinter          *self,
+                            GAsyncResult       *res,
+                            GError            **error)
+{
+  g_return_val_if_fail (g_task_is_valid (res, self), NULL);
+
+  return g_task_propagate_pointer (G_TASK (res), error);
+}
+
+static void
+pp_printer_delete_dbus_cb (GObject      *source_object,
+                           GAsyncResult *res,
+                           gpointer      user_data)
+{
+  PpPrinter *self;
+  g_autoptr(GVariant) output = NULL;
+  gboolean            result = FALSE;
+  g_autoptr(GError)   error = NULL;
+  GTask              *task = user_data;
+
+  output = g_dbus_connection_call_finish (G_DBUS_CONNECTION (source_object),
+                                          res,
+                                          &error);
+
+  if (output != NULL)
+    {
+      const gchar      *ret_error;
+
+      self = g_task_get_source_object (task);
+
+      g_variant_get (output, "(&s)", &ret_error);
+      if (ret_error[0] != '\0')
+        g_warning ("cups-pk-helper: removing of printer %s failed: %s", self->printer_name, ret_error);
+      else
+        result = TRUE;
+
+      g_task_return_boolean (task, result);
+    }
+  else
+    {
+      g_warning ("%s", error->message);
+
+      g_task_return_boolean (task, FALSE);
+    }
+}
+
+static void
+pp_printer_delete_cb (GObject      *source_object,
+                      GAsyncResult *res,
+                      gpointer      user_data)
+{
+  PpPrinter *self;
+  GDBusConnection  *bus;
+  g_autoptr(GError) error = NULL;
+  GTask            *task = user_data;
+
+  bus = g_bus_get_finish (res, &error);
+  if (bus != NULL)
+    {
+      self = g_task_get_source_object (task);
+
+      g_dbus_connection_call (bus,
+                              MECHANISM_BUS,
+                              "/",
+                              MECHANISM_BUS,
+                              "PrinterDelete",
+                              g_variant_new ("(s)", self->printer_name),
+                              G_VARIANT_TYPE ("(s)"),
+                              G_DBUS_CALL_FLAGS_NONE,
+                              -1,
+                              g_task_get_cancellable (task),
+                              pp_printer_delete_dbus_cb,
+                              task);
+    }
+  else
+    {
+      g_warning ("Failed to get system bus: %s", error->message);
+      g_task_return_boolean (task, FALSE);
+    }
+}
+
+void
+pp_printer_delete_async (PpPrinter           *self,
+                         GCancellable        *cancellable,
+                         GAsyncReadyCallback  callback,
+                         gpointer             user_data)
+{
+  GTask *task;
+
+  task = g_task_new (G_OBJECT (self), cancellable, callback, user_data);
+
+  g_bus_get (G_BUS_TYPE_SYSTEM,
+             cancellable,
+             pp_printer_delete_cb,
+             task);
+}
+
+gboolean
+pp_printer_delete_finish (PpPrinter     *self,
+                          GAsyncResult  *res,
+                          GError       **error)
+{
+  g_return_val_if_fail (g_task_is_valid (res, self), FALSE);
+
+  return g_task_propagate_boolean (G_TASK (res), error);
+}
+
+typedef struct
+{
+  gchar *filename;
+  gchar *job_name;
+} PrintFileData;
+
+static void
+print_file_data_free (PrintFileData *print_file_data)
+{
+  g_free (print_file_data->filename);
+  g_free (print_file_data->job_name);
+
+  g_slice_free (PrintFileData, print_file_data);
+}
+
+static void
+print_file_thread (GTask        *task,
+                   gpointer      source_object,
+                   gpointer      task_data,
+                   GCancellable *cancellable)
+{
+  PpPrinter        *self = PP_PRINTER (source_object);
+  PrintFileData    *print_file_data;
+  cups_ptype_t      type = 0;
+  cups_dest_t      *dest = NULL;
+  const gchar      *printer_type = NULL;
+  gboolean          ret = FALSE;
+  g_autofree gchar *printer_uri = NULL;
+  g_autofree gchar *resource = NULL;
+  ipp_t            *response = NULL;
+  ipp_t            *request;
+
+  dest = cupsGetNamedDest (CUPS_HTTP_DEFAULT, self->printer_name, NULL);
+  if (dest != NULL)
+    {
+      printer_type = cupsGetOption ("printer-type",
+                                    dest->num_options,
+                                    dest->options);
+      cupsFreeDests (1, dest);
+
+      if (printer_type)
+        type = atoi (printer_type);
+    }
+
+  if (type & CUPS_PRINTER_CLASS)
+    {
+      printer_uri = g_strdup_printf ("ipp://localhost/classes/%s", self->printer_name);
+      resource = g_strdup_printf ("/classes/%s", self->printer_name);
+    }
+  else
+    {
+      printer_uri = g_strdup_printf ("ipp://localhost/printers/%s", self->printer_name);
+      resource = g_strdup_printf ("/printers/%s", self->printer_name);
+    }
+
+  print_file_data = g_task_get_task_data (task);
+
+  request = ippNewRequest (IPP_PRINT_JOB);
+  ippAddString (request, IPP_TAG_OPERATION, IPP_TAG_URI,
+                "printer-uri", NULL, printer_uri);
+  ippAddString (request, IPP_TAG_OPERATION, IPP_TAG_NAME,
+                "requesting-user-name", NULL, cupsUser ());
+  ippAddString (request, IPP_TAG_OPERATION, IPP_TAG_NAME,
+                "job-name", NULL, print_file_data->job_name);
+  response = cupsDoFileRequest (CUPS_HTTP_DEFAULT, request, resource, print_file_data->filename);
+
+  if (response != NULL)
+    {
+      if (ippGetState (response) == IPP_ERROR)
+        g_warning ("An error has occurred during printing of test page.");
+      if (ippGetState (response) == IPP_STATE_IDLE)
+        ret = TRUE;
+
+      ippDelete (response);
+    }
+
+  if (g_task_set_return_on_cancel (task, FALSE))
+    {
+      g_task_return_boolean (task, ret);
+    }
+}
+
+void
+pp_printer_print_file_async (PpPrinter           *self,
+                             const gchar         *filename,
+                             const gchar         *job_name,
+                             GCancellable        *cancellable,
+                             GAsyncReadyCallback  callback,
+                             gpointer             user_data)
+{
+  PrintFileData *print_file_data;
+  g_autoptr(GTask) task = NULL;
+
+  print_file_data = g_new (PrintFileData, 1);
+  print_file_data->filename = g_strdup (filename);
+  print_file_data->job_name = g_strdup (job_name);
+
+  task = g_task_new (G_OBJECT (self), cancellable, callback, user_data);
+
+  g_task_set_return_on_cancel (task, TRUE);
+  g_task_set_task_data (task, print_file_data, (GDestroyNotify) print_file_data_free);
+
+  g_task_run_in_thread (task, print_file_thread);
+}
+
+gboolean
+pp_printer_print_file_finish (PpPrinter     *self,
+                              GAsyncResult  *res,
+                              GError       **error)
+{
+  g_return_val_if_fail (g_task_is_valid (res, self), FALSE);
+
+  return g_task_propagate_boolean (G_TASK (res), error);
+}
diff --git a/panels/printers/pp-printer.h b/panels/printers/pp-printer.h
new file mode 100644
index 0000000..a63fbb9
--- /dev/null
+++ b/panels/printers/pp-printer.h
@@ -0,0 +1,80 @@
+/*
+ * Copyright (C) 2016 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 2 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, see <http://www.gnu.org/licenses/>.
+ *
+ * Authors: Martin Hatina <mhatina@redhat.com>
+ *          Marek Kasik <mkasik@redhat.com>
+ */
+
+#pragma once
+
+#include <glib-object.h>
+#include <gio/gio.h>
+
+#include "pp-utils.h"
+
+G_BEGIN_DECLS
+
+#define PP_TYPE_PRINTER (pp_printer_get_type ())
+G_DECLARE_FINAL_TYPE (PpPrinter, pp_printer, PP, PRINTER, GObject)
+
+GType        pp_printer_get_type      (void) G_GNUC_CONST;
+
+PpPrinter   *pp_printer_new           (const gchar          *name);
+
+const gchar *pp_printer_get_name      (PpPrinter            *printer);
+
+void         pp_printer_rename_async  (PpPrinter            *printer,
+                                       const gchar          *new_printer_name,
+                                       GCancellable         *cancellable,
+                                       GAsyncReadyCallback   callback,
+                                       gpointer              user_data);
+
+gboolean     pp_printer_rename_finish (PpPrinter            *printer,
+                                       GAsyncResult         *res,
+                                       GError              **error);
+
+void         pp_printer_delete_async  (PpPrinter            *printer,
+                                       GCancellable         *cancellable,
+                                       GAsyncReadyCallback   callback,
+                                       gpointer              user_data);
+
+gboolean     pp_printer_delete_finish (PpPrinter            *printer,
+                                       GAsyncResult         *res,
+                                       GError              **error);
+
+void         pp_printer_get_jobs_async (PpPrinter           *printer,
+                                        gboolean             myjobs,
+                                        gint                 which_jobs,
+                                        GCancellable        *cancellable,
+                                        GAsyncReadyCallback  callback,
+                                        gpointer             user_data);
+
+GPtrArray   *pp_printer_get_jobs_finish (PpPrinter          *printer,
+                                         GAsyncResult       *res,
+                                         GError            **error);
+
+void         pp_printer_print_file_async (PpPrinter           *printer,
+                                          const gchar         *filename,
+                                          const gchar         *job_name,
+                                          GCancellable        *cancellable,
+                                          GAsyncReadyCallback  callback,
+                                          gpointer             user_data);
+
+gboolean     pp_printer_print_file_finish (PpPrinter         *printer,
+                                           GAsyncResult      *res,
+                                           GError           **error);
+
+G_END_DECLS
diff --git a/panels/printers/pp-samba.c b/panels/printers/pp-samba.c
new file mode 100644
index 0000000..5eaf5b7
--- /dev/null
+++ b/panels/printers/pp-samba.c
@@ -0,0 +1,414 @@
+/* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 8 -*-
+ *
+ * Copyright 2012 - 2013 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 2 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, see <http://www.gnu.org/licenses/>.
+ *
+ * Author: Marek Kasik <mkasik@redhat.com>
+ */
+
+#include "pp-samba.h"
+
+#include "config.h"
+
+#include <glib/gi18n.h>
+#include <libsmbclient.h>
+#include <errno.h>
+
+#define POLL_DELAY 100000
+
+struct _PpSamba
+{
+  PpHost    parent_instance;
+
+  /* Auth info */
+  gchar    *username;
+  gchar    *password;
+  gboolean  waiting;
+};
+
+G_DEFINE_TYPE (PpSamba, pp_samba, PP_TYPE_HOST);
+
+static void
+pp_samba_finalize (GObject *object)
+{
+  PpSamba *self = PP_SAMBA (object);
+
+  g_clear_pointer (&self->username, g_free);
+  g_clear_pointer (&self->password, g_free);
+
+  G_OBJECT_CLASS (pp_samba_parent_class)->finalize (object);
+}
+
+static void
+pp_samba_class_init (PpSambaClass *klass)
+{
+  GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
+
+  gobject_class->finalize = pp_samba_finalize;
+}
+
+static void
+pp_samba_init (PpSamba *samba)
+{
+}
+
+PpSamba *
+pp_samba_new (const gchar *hostname)
+{
+  return g_object_new (PP_TYPE_SAMBA,
+                       "hostname", hostname,
+                       NULL);
+}
+
+typedef struct
+{
+  PpSamba       *samba;
+  GPtrArray     *devices;
+  GMainContext  *context;
+  gboolean       auth_if_needed;
+  gboolean       hostname_set;
+  gboolean       cancelled;
+} SMBData;
+
+static void
+smb_data_free (SMBData *data)
+{
+  if (data)
+    {
+      g_ptr_array_unref (data->devices);
+
+      g_free (data);
+    }
+}
+
+static gboolean
+get_auth_info (gpointer user_data)
+{
+  SMBData *data = (SMBData *) user_data;
+  PpSamba *samba = PP_SAMBA (data->samba);
+
+  g_signal_emit_by_name (samba, "authentication-required");
+
+  return FALSE;
+}
+
+void
+pp_samba_set_auth_info (PpSamba     *samba,
+                        const gchar *username,
+                        const gchar *password)
+{
+  g_free (samba->username);
+  if ((username != NULL) && (username[0] != '\0'))
+    samba->username = g_strdup (username);
+  else
+    samba->username = NULL;
+
+  g_free (samba->password);
+  if ((password != NULL) && (password[0] != '\0'))
+    samba->password = g_strdup (password);
+  else
+    samba->password = NULL;
+
+  samba->waiting = FALSE;
+}
+
+static void
+auth_fn (SMBCCTX    *smb_context,
+         const char *server,
+         const char *share,
+         char       *workgroup,
+         int         wgmaxlen,
+         char       *username,
+         int         unmaxlen,
+         char       *password,
+         int         pwmaxlen)
+{
+  PpSamba           *samba;
+  g_autoptr(GSource) source = NULL;
+  SMBData           *data;
+
+  data = (SMBData *) smbc_getOptionUserData (smb_context);
+  samba = data->samba;
+
+  if (!data->cancelled)
+    {
+      samba->username = g_strdup (username);
+      samba->password = g_strdup (password);
+
+      source = g_idle_source_new ();
+      g_source_set_callback (source,
+                             get_auth_info,
+                             data,
+                             NULL);
+      g_source_attach (source, data->context);
+
+      samba->waiting = TRUE;
+
+      /*
+       * smbclient needs to get authentication data
+       * from this synchronous callback so we are blocking
+       * until we get them
+       */
+      while (samba->waiting)
+        {
+          g_usleep (POLL_DELAY);
+        }
+
+      /* Samba tries to call the auth_fn again if we just set the values
+       * to NULL when we want to cancel the authentication 
+       */
+      if (samba->username == NULL && samba->password == NULL)
+        data->cancelled = TRUE;
+
+      if (samba->username != NULL)
+        {
+          if (g_strcmp0 (username, samba->username) != 0)
+            g_strlcpy (username, samba->username, unmaxlen);
+        }
+      else
+        {
+          username[0] = '\0';
+        }
+
+      if (samba->password != NULL)
+        {
+          if (g_strcmp0 (password, samba->password) != 0)
+            g_strlcpy (password, samba->password, pwmaxlen);
+        }
+      else
+        {
+          password[0] = '\0';
+        }
+
+    }
+}
+
+static void
+anonymous_auth_fn (SMBCCTX    *smb_context,
+                   const char *server,
+                   const char *share,
+                   char       *workgroup,
+                   int         wgmaxlen,
+                   char       *username,
+                   int         unmaxlen,
+                   char       *password,
+                   int         pwmaxlen)
+{
+  username[0] = '\0';
+  password[0] = '\0';
+}
+
+static void
+list_dir (SMBCCTX      *smb_context,
+          const gchar  *dirname,
+          const gchar  *path,
+          GCancellable *cancellable,
+          SMBData      *data)
+{
+  struct smbc_dirent *dirent;
+  smbc_closedir_fn    smbclient_closedir;
+  smbc_readdir_fn     smbclient_readdir;
+  smbc_opendir_fn     smbclient_opendir;
+  const gchar        *host_name;
+  SMBCFILE           *dir;
+
+  if (!g_cancellable_is_cancelled (cancellable))
+    {
+      smbclient_closedir = smbc_getFunctionClosedir (smb_context);
+      smbclient_readdir = smbc_getFunctionReaddir (smb_context);
+      smbclient_opendir = smbc_getFunctionOpendir (smb_context);
+
+      dir = smbclient_opendir (smb_context, dirname);
+      if (!dir && errno == EACCES)
+        {
+          if (g_str_has_prefix (dirname, "smb://"))
+            host_name = dirname + 6;
+          else
+            host_name = dirname;
+
+          if (data->auth_if_needed)
+            {
+              data->cancelled = FALSE;
+              smbc_setFunctionAuthDataWithContext (smb_context, auth_fn);
+              dir = smbclient_opendir (smb_context, dirname);
+              smbc_setFunctionAuthDataWithContext (smb_context, anonymous_auth_fn);
+
+              if (data->cancelled)
+                {
+                  PpPrintDevice *device = g_object_new (PP_TYPE_PRINT_DEVICE,
+                                                        "host-name", host_name,
+                                                        "is-authenticated-server", TRUE,
+                                                        NULL);
+                  g_ptr_array_add (data->devices, device);
+
+                  if (dir)
+                    smbclient_closedir (smb_context, dir);
+                  return;
+                }
+            }
+          else
+            {
+              PpPrintDevice *device = g_object_new (PP_TYPE_PRINT_DEVICE,
+                                                    "host-name", host_name,
+                                                    "is-authenticated-server", TRUE,
+                                                    NULL);
+              g_ptr_array_add (data->devices, device);
+            }
+        }
+
+      while (dir && (dirent = smbclient_readdir (smb_context, dir)))
+        {
+          g_autofree gchar *subdirname = NULL;
+          g_autofree gchar *subpath = NULL;
+
+          if (dirent->smbc_type == SMBC_WORKGROUP)
+            {
+              subdirname = g_strdup_printf ("%s%s", dirname, dirent->name);
+              subpath = g_strdup_printf ("%s%s", path, dirent->name);
+            }
+
+          if (dirent->smbc_type == SMBC_SERVER)
+            {
+              subdirname = g_strdup_printf ("smb://%s", dirent->name);
+              subpath = g_strdup_printf ("%s//%s", path, dirent->name);
+            }
+
+          if (dirent->smbc_type == SMBC_PRINTER_SHARE)
+            {
+              g_autofree gchar *uri = NULL;
+              g_autofree gchar *device_name = NULL;
+              g_autofree gchar *device_uri = NULL;
+              PpPrintDevice *device;
+
+              uri = g_strdup_printf ("%s/%s", dirname, dirent->name);
+              device_uri = g_uri_escape_string (uri,
+                                                G_URI_RESERVED_CHARS_GENERIC_DELIMITERS
+                                                G_URI_RESERVED_CHARS_SUBCOMPONENT_DELIMITERS,
+                                                FALSE);
+
+              device_name = g_strdup (dirent->name);
+              g_strcanon (device_name, ALLOWED_CHARACTERS, '-');
+
+              device = g_object_new (PP_TYPE_PRINT_DEVICE,
+                                     "device-uri", device_uri,
+                                     "is-network-device", TRUE,
+                                     "device-info", dirent->comment,
+                                     "device-name", device_name,
+                                     "acquisition-method", data->hostname_set ? ACQUISITION_METHOD_SAMBA_HOST : ACQUISITION_METHOD_SAMBA,
+                                     "device-location", path,
+                                     "host-name", dirname,
+                                     NULL);
+
+              g_ptr_array_add (data->devices, device);
+            }
+
+          if (subdirname)
+            {
+              list_dir (smb_context,
+                        subdirname,
+                        subpath,
+                        cancellable,
+                        data);
+            }
+        }
+
+      if (dir)
+        smbclient_closedir (smb_context, dir);
+    }
+}
+
+static void
+_pp_samba_get_devices_thread (GTask        *task,
+                              gpointer      source_object,
+                              gpointer      task_data,
+                              GCancellable *cancellable)
+{
+  static GMutex   mutex;
+  SMBData        *data = (SMBData *) task_data;
+  SMBCCTX        *smb_context;
+
+  data->devices = g_ptr_array_new_with_free_func (g_object_unref);
+  data->samba = PP_SAMBA (source_object);
+
+  g_mutex_lock (&mutex);
+
+  smb_context = smbc_new_context ();
+  if (smb_context)
+    {
+      if (smbc_init_context (smb_context))
+        {
+          g_autofree gchar *hostname = NULL;
+          g_autofree gchar *dirname = NULL;
+          g_autofree gchar *path = NULL;
+
+          smbc_setOptionUserData (smb_context, data);
+
+          g_object_get (source_object, "hostname", &hostname, NULL);
+          if (hostname != NULL)
+            {
+              dirname = g_strdup_printf ("smb://%s", hostname);
+              path = g_strdup_printf ("//%s", hostname);
+            }
+          else
+            {
+              dirname = g_strdup_printf ("smb://");
+              path = g_strdup_printf ("//");
+            }
+
+          smbc_setFunctionAuthDataWithContext (smb_context, anonymous_auth_fn);
+          list_dir (smb_context, dirname, path, cancellable, data);
+        }
+
+      smbc_free_context (smb_context, 1);
+    }
+
+  g_mutex_unlock (&mutex);
+
+  g_task_return_pointer (task, g_ptr_array_ref (data->devices), (GDestroyNotify) g_ptr_array_unref);
+}
+
+void
+pp_samba_get_devices_async (PpSamba             *samba,
+                            gboolean             auth_if_needed,
+                            GCancellable        *cancellable,
+                            GAsyncReadyCallback  callback,
+                            gpointer             user_data)
+{
+  g_autoptr(GTask)  task = NULL;
+  SMBData          *data;
+  g_autofree gchar *hostname = NULL;
+
+  g_object_get (G_OBJECT (samba), "hostname", &hostname, NULL);
+
+  task = g_task_new (samba, cancellable, callback, user_data);
+  data = g_new0 (SMBData, 1);
+  data->devices = NULL;
+  data->context = g_main_context_default ();
+  data->hostname_set = hostname != NULL;
+  data->auth_if_needed = auth_if_needed;
+
+  g_task_set_task_data (task, data, (GDestroyNotify) smb_data_free);
+  g_task_run_in_thread (task, _pp_samba_get_devices_thread);
+}
+
+GPtrArray *
+pp_samba_get_devices_finish (PpSamba       *samba,
+                             GAsyncResult  *res,
+                             GError       **error)
+{
+  g_return_val_if_fail (g_task_is_valid (res, samba), NULL);
+  g_return_val_if_fail (error == NULL || *error == NULL, NULL);
+  return g_task_propagate_pointer (G_TASK (res), error);
+}
diff --git a/panels/printers/pp-samba.h b/panels/printers/pp-samba.h
new file mode 100644
index 0000000..0801317
--- /dev/null
+++ b/panels/printers/pp-samba.h
@@ -0,0 +1,47 @@
+/* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 8 -*-
+ *
+ * Copyright 2012 - 2013 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 2 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, see <http://www.gnu.org/licenses/>.
+ *
+ * Author: Marek Kasik <mkasik@redhat.com>
+ */
+
+#pragma once
+
+#include "pp-host.h"
+#include "pp-utils.h"
+
+G_BEGIN_DECLS
+
+#define PP_TYPE_SAMBA (pp_samba_get_type ())
+G_DECLARE_FINAL_TYPE (PpSamba, pp_samba, PP, SAMBA, PpHost)
+
+PpSamba       *pp_samba_new                (const gchar         *hostname);
+
+void           pp_samba_get_devices_async  (PpSamba             *samba,
+                                            gboolean             auth_if_needed,
+                                            GCancellable        *cancellable,
+                                            GAsyncReadyCallback  callback,
+                                            gpointer             user_data);
+
+GPtrArray     *pp_samba_get_devices_finish (PpSamba             *samba,
+                                            GAsyncResult        *result,
+                                            GError             **error);
+
+void           pp_samba_set_auth_info      (PpSamba             *samba,
+                                            const gchar         *username,
+                                            const gchar         *password);
+
+G_END_DECLS
diff --git a/panels/printers/pp-utils.c b/panels/printers/pp-utils.c
new file mode 100644
index 0000000..750b634
--- /dev/null
+++ b/panels/printers/pp-utils.c
@@ -0,0 +1,3645 @@
+/* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 8 -*-
+ *
+ * Copyright 2009-2010  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 2 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, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#include "config.h"
+
+#include <glib.h>
+#include <glib/gi18n.h>
+#include <glib/gstdio.h>
+#include <gtk/gtk.h>
+#include <cups/cups.h>
+#include <cups/ppd.h>
+
+#include "pp-utils.h"
+
+#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 ippGetCount(attr)     attr->num_values
+#define ippGetGroupTag(attr)  attr->group_tag
+#define ippGetValueTag(attr)  attr->value_tag
+#define ippGetName(attr)      attr->name
+#define ippGetStatusCode(ipp) ipp->request.status.status_code
+#define ippGetInteger(attr, element) attr->values[element].integer
+#define ippGetString(attr, element, language) attr->values[element].string.text
+#define ippGetBoolean(attr, element) attr->values[element].boolean
+
+static int
+ippGetRange (ipp_attribute_t *attr,
+             int element,
+             int *upper)
+{
+  *upper = attr->values[element].range.upper;
+  return (attr->values[element].range.lower);
+}
+
+static ipp_attribute_t *
+ippFirstAttribute (ipp_t *ipp)
+{
+  if (!ipp)
+    return (NULL);
+  return (ipp->current = ipp->attrs);
+}
+
+static ipp_attribute_t *
+ippNextAttribute (ipp_t *ipp)
+{
+  if (!ipp || !ipp->current)
+    return (NULL);
+  return (ipp->current = ipp->current->next);
+}
+#endif
+
+#if (CUPS_VERSION_MAJOR == 1) && (CUPS_VERSION_MINOR <= 6)
+#define HTTP_URI_STATUS_OK HTTP_URI_OK
+#endif
+
+gchar *
+get_tag_value (const gchar *tag_string, const gchar *tag_name)
+{
+  gchar **tag_string_splitted = NULL;
+  gchar  *tag_value = NULL;
+  gint    tag_name_length;
+  gint    i;
+
+  if (tag_string && tag_name)
+    {
+      tag_name_length = strlen (tag_name);
+      tag_string_splitted = g_strsplit (tag_string, ";", 0);
+      if (tag_string_splitted)
+        {
+          for (i = 0; i < g_strv_length (tag_string_splitted); i++)
+            if (g_ascii_strncasecmp (tag_string_splitted[i], tag_name, tag_name_length) == 0)
+              if (strlen (tag_string_splitted[i]) > tag_name_length + 1)
+                tag_value = g_strdup (tag_string_splitted[i] + tag_name_length + 1);
+
+          g_strfreev (tag_string_splitted);
+        }
+    }
+
+  return tag_value;
+}
+
+
+/*
+ * Normalize given string so that it is lowercase, doesn't
+ * have trailing or leading whitespaces and digits doesn't
+ * neighbour with alphabetic.
+ * (see cupshelpers/ppds.py from system-config-printer)
+ */
+static gchar *
+normalize (const gchar *input_string)
+{
+  gchar *result = NULL;
+  gint   i, j = 0, k = -1;
+
+  if (input_string)
+    {
+      g_autofree gchar *tmp = g_strstrip (g_ascii_strdown (input_string, -1));
+      if (tmp)
+        {
+          g_autofree gchar *res = g_new (gchar, 2 * strlen (tmp));
+
+          for (i = 0; i < strlen (tmp); i++)
+            {
+              if ((g_ascii_isalpha (tmp[i]) && k >= 0 && g_ascii_isdigit (res[k])) ||
+                  (g_ascii_isdigit (tmp[i]) && k >= 0 && g_ascii_isalpha (res[k])))
+                {
+                  res[j] = ' ';
+                  k = j++;
+                  res[j] = tmp[i];
+                  k = j++;
+                }
+              else
+                {
+                  if (g_ascii_isspace (tmp[i]) || !g_ascii_isalnum (tmp[i]))
+                    {
+                      if (!(k >= 0 && res[k] == ' '))
+                        {
+                          res[j] = ' ';
+                          k = j++;
+                        }
+                    }
+                  else
+                    {
+                      res[j] = tmp[i];
+                      k = j++;
+                    }
+                }
+            }
+
+          res[j] = '\0';
+
+          result = g_strdup (res);
+        }
+    }
+
+  return result;
+}
+
+
+char *
+get_dest_attr (const char *dest_name,
+               const char *attr)
+{
+  cups_dest_t *dests;
+  int          num_dests;
+  cups_dest_t *dest;
+  const char  *value;
+  char        *ret;
+
+  if (dest_name == NULL)
+          return NULL;
+
+  ret = NULL;
+
+  num_dests = cupsGetDests (&dests);
+  if (num_dests < 1) {
+          g_debug ("Unable to get printer destinations");
+          return NULL;
+  }
+
+  dest = cupsGetDest (dest_name, NULL, num_dests, dests);
+  if (dest == NULL) {
+          g_debug ("Unable to find a printer named '%s'", dest_name);
+          goto out;
+  }
+
+  value = cupsGetOption (attr, dest->num_options, dest->options);
+  if (value == NULL) {
+          g_debug ("Unable to get %s for '%s'", attr, dest_name);
+          goto out;
+  }
+  ret = g_strdup (value);
+out:
+  cupsFreeDests (num_dests, dests);
+
+  return ret;
+}
+
+gchar *
+get_ppd_attribute (const gchar *ppd_file_name,
+                   const gchar *attribute_name)
+{
+  ppd_file_t *ppd_file = NULL;
+  ppd_attr_t *ppd_attr = NULL;
+  gchar *result = NULL;
+
+  if (ppd_file_name)
+    {
+      ppd_file = ppdOpenFile (ppd_file_name);
+
+      if (ppd_file)
+        {
+          ppd_attr = ppdFindAttr (ppd_file, attribute_name, NULL);
+          if (ppd_attr != NULL)
+            result = g_strdup (ppd_attr->value);
+          ppdClose (ppd_file);
+        }
+    }
+
+  return result;
+}
+
+/*  Set default destination in ~/.cups/lpoptions.
+ *  Unset default destination if "dest" is NULL.
+ */
+void
+set_local_default_printer (const gchar *printer_name)
+{
+  cups_dest_t *dests = NULL;
+  int          num_dests = 0;
+  int          i;
+
+  num_dests = cupsGetDests (&dests);
+
+  for (i = 0; i < num_dests; i ++)
+    {
+      if (printer_name && g_strcmp0 (dests[i].name, printer_name) == 0)
+        dests[i].is_default = 1;
+      else
+        dests[i].is_default = 0;
+    }
+
+  cupsSetDests (num_dests, dests);
+}
+
+/*
+ * This function does something which should be provided by CUPS...
+ * It returns FALSE if the renaming fails.
+ */
+gboolean
+printer_rename (const gchar *old_name,
+                const gchar *new_name)
+{
+  ipp_attribute_t  *attr = NULL;
+  cups_ptype_t      printer_type = 0;
+  cups_dest_t      *dests = NULL;
+  cups_dest_t      *dest = NULL;
+  cups_job_t       *jobs = NULL;
+  g_autoptr(GDBusConnection) bus = NULL;
+  const gchar      *printer_location = NULL;
+  const gchar      *printer_info = NULL;
+  const gchar      *printer_uri = NULL;
+  const gchar      *device_uri = NULL;
+  const gchar      *job_sheets = NULL;
+  gboolean          result = FALSE;
+  gboolean          accepting = TRUE;
+  gboolean          printer_paused = FALSE;
+  gboolean          default_printer = FALSE;
+  gboolean          printer_shared = FALSE;
+  g_autoptr(GError) error = NULL;
+  http_t           *http;
+  g_autofree gchar *ppd_link = NULL;
+  g_autofree gchar *ppd_filename = NULL;
+  gchar           **sheets = NULL;
+  gchar           **users_allowed = NULL;
+  gchar           **users_denied = NULL;
+  gchar           **member_names = NULL;
+  const gchar      *start_sheet = NULL;
+  const gchar      *end_sheet = NULL;
+  g_autofree gchar *error_policy = NULL;
+  g_autofree gchar *op_policy = NULL;
+  ipp_t            *request;
+  ipp_t            *response;
+  gint              i;
+  int               num_dests = 0;
+  int               num_jobs = 0;
+  static const char * const requested_attrs[] = {
+    "printer-error-policy",
+    "printer-op-policy",
+    "requesting-user-name-allowed",
+    "requesting-user-name-denied",
+    "member-names"};
+
+  if (old_name == NULL ||
+      old_name[0] == '\0' ||
+      new_name == NULL ||
+      new_name[0] == '\0' ||
+      g_strcmp0 (old_name, new_name) == 0)
+    return FALSE;
+
+  num_dests = cupsGetDests (&dests);
+
+  dest = cupsGetDest (new_name, NULL, num_dests, dests);
+  if (dest)
+    {
+      cupsFreeDests (num_dests, dests);
+      return FALSE;
+    }
+
+  num_jobs = cupsGetJobs (&jobs, old_name, 0, CUPS_WHICHJOBS_ACTIVE);
+  cupsFreeJobs (num_jobs, jobs);
+  if (num_jobs > 1)
+    {
+      g_warning ("There are queued jobs on printer %s!", old_name);
+      cupsFreeDests (num_dests, dests);
+      return FALSE;
+    }
+
+  /*
+   * Gather some informations about the original printer
+   */
+  dest = cupsGetDest (old_name, NULL, num_dests, dests);
+  if (dest)
+    {
+      for (i = 0; i < dest->num_options; i++)
+        {
+          if (g_strcmp0 (dest->options[i].name, "printer-is-accepting-jobs") == 0)
+            accepting = g_strcmp0 (dest->options[i].value, "true") == 0;
+          else if (g_strcmp0 (dest->options[i].name, "printer-is-shared") == 0)
+            printer_shared = g_strcmp0 (dest->options[i].value, "true") == 0;
+          else if (g_strcmp0 (dest->options[i].name, "device-uri") == 0)
+            device_uri = dest->options[i].value;
+          else if (g_strcmp0 (dest->options[i].name, "printer-uri-supported") == 0)
+            printer_uri = dest->options[i].value;
+          else if (g_strcmp0 (dest->options[i].name, "printer-info") == 0)
+            printer_info = dest->options[i].value;
+          else if (g_strcmp0 (dest->options[i].name, "printer-location") == 0)
+            printer_location = dest->options[i].value;
+          else if (g_strcmp0 (dest->options[i].name, "printer-state") == 0)
+            printer_paused = g_strcmp0 (dest->options[i].value, "5") == 0;
+          else if (g_strcmp0 (dest->options[i].name, "job-sheets") == 0)
+            job_sheets = dest->options[i].value;
+          else if (g_strcmp0 (dest->options[i].name, "printer-type") == 0)
+            printer_type = atoi (dest->options[i].value);
+        }
+      default_printer = dest->is_default;
+    }
+  cupsFreeDests (num_dests, dests);
+
+  if (accepting)
+    {
+      printer_set_accepting_jobs (old_name, FALSE, NULL);
+
+      num_jobs = cupsGetJobs (&jobs, old_name, 0, CUPS_WHICHJOBS_ACTIVE);
+      cupsFreeJobs (num_jobs, jobs);
+      if (num_jobs > 1)
+        {
+          printer_set_accepting_jobs (old_name, accepting, NULL);
+          g_warning ("There are queued jobs on printer %s!", old_name);
+          return FALSE;
+        }
+    }
+
+
+  /*
+   * Gather additional informations about the original printer
+   */
+#ifdef HAVE_CUPS_HTTPCONNECT2
+  http = httpConnect2 (cupsServer (), ippPort (), NULL, AF_UNSPEC,
+                       cupsEncryption (), 1, 30000, NULL);
+#else
+  http = httpConnectEncrypt (cupsServer (), ippPort (), cupsEncryption ());
+#endif
+  if (http != NULL)
+    {
+      request = ippNewRequest (IPP_GET_PRINTER_ATTRIBUTES);
+      ippAddString (request, IPP_TAG_OPERATION, IPP_TAG_URI,
+                    "printer-uri", NULL, printer_uri);
+      ippAddStrings (request, IPP_TAG_OPERATION, IPP_TAG_KEYWORD,
+                     "requested-attributes", G_N_ELEMENTS (requested_attrs), NULL, requested_attrs);
+      response = cupsDoRequest (http, request, "/");
+
+      if (response)
+        {
+          if (ippGetStatusCode (response) <= IPP_OK_CONFLICT)
+            {
+              attr = ippFindAttribute (response, "printer-error-policy", IPP_TAG_NAME);
+              if (attr)
+                error_policy = g_strdup (ippGetString (attr, 0, NULL));
+
+              attr = ippFindAttribute (response, "printer-op-policy", IPP_TAG_NAME);
+              if (attr)
+                op_policy = g_strdup (ippGetString (attr, 0, NULL));
+
+              attr = ippFindAttribute (response, "requesting-user-name-allowed", IPP_TAG_NAME);
+              if (attr && ippGetCount (attr) > 0)
+                {
+                  users_allowed = g_new0 (gchar *, ippGetCount (attr) + 1);
+                  for (i = 0; i < ippGetCount (attr); i++)
+                    users_allowed[i] = g_strdup (ippGetString (attr, i, NULL));
+                }
+
+              attr = ippFindAttribute (response, "requesting-user-name-denied", IPP_TAG_NAME);
+              if (attr && ippGetCount (attr) > 0)
+                {
+                  users_denied = g_new0 (gchar *, ippGetCount (attr) + 1);
+                  for (i = 0; i < ippGetCount (attr); i++)
+                    users_denied[i] = g_strdup (ippGetString (attr, i, NULL));
+                }
+
+              attr = ippFindAttribute (response, "member-names", IPP_TAG_NAME);
+              if (attr && ippGetCount (attr) > 0)
+                {
+                  member_names = g_new0 (gchar *, ippGetCount (attr) + 1);
+                  for (i = 0; i < ippGetCount (attr); i++)
+                    member_names[i] = g_strdup (ippGetString (attr, i, NULL));
+                }
+            }
+          ippDelete (response);
+        }
+      httpClose (http);
+    }
+
+  if (job_sheets)
+    {
+      sheets = g_strsplit (job_sheets, ",", 0);
+      if (g_strv_length (sheets) > 1)
+        {
+          start_sheet = sheets[0];
+          end_sheet = sheets[1];
+        }
+    }
+
+  ppd_link = g_strdup (cupsGetPPD (old_name));
+  if (ppd_link)
+    {
+      ppd_filename = g_file_read_link (ppd_link, NULL);
+
+      if (!ppd_filename)
+        ppd_filename = g_strdup (ppd_link);
+    }
+
+
+  bus = g_bus_get_sync (G_BUS_TYPE_SYSTEM, NULL, &error);
+  if (!bus)
+   {
+     g_warning ("Failed to get system bus: %s", error->message);
+   }
+  else
+    {
+      if (printer_type & CUPS_PRINTER_CLASS)
+        {
+          if (member_names)
+            for (i = 0; i < g_strv_length (member_names); i++)
+              class_add_printer (new_name, member_names[i]);
+        }
+      else
+        {
+          g_autoptr(GVariant) output = NULL;
+          g_autoptr(GError) add_error = NULL;
+
+          output = g_dbus_connection_call_sync (bus,
+                                                MECHANISM_BUS,
+                                                "/",
+                                                MECHANISM_BUS,
+                                                "PrinterAddWithPpdFile",
+                                                g_variant_new ("(sssss)",
+                                                               new_name,
+                                                               device_uri ? device_uri : "",
+                                                               ppd_filename ? ppd_filename : "",
+                                                               printer_info ? printer_info : "",
+                                                               printer_location ? printer_location : ""),
+                                                G_VARIANT_TYPE ("(s)"),
+                                                G_DBUS_CALL_FLAGS_NONE,
+                                                -1,
+                                                NULL,
+                                                &add_error);
+
+          if (output)
+            {
+              const gchar *ret_error;
+
+              g_variant_get (output, "(&s)", &ret_error);
+              if (ret_error[0] != '\0')
+                g_warning ("cups-pk-helper: rename of printer %s to %s failed: %s", old_name, new_name, ret_error);
+            }
+          else
+            {
+              g_warning ("%s", add_error->message);
+            }
+        }
+    }
+
+  if (ppd_link)
+    {
+      g_unlink (ppd_link);
+    }
+
+  num_dests = cupsGetDests (&dests);
+  dest = cupsGetDest (new_name, NULL, num_dests, dests);
+  if (dest)
+    {
+      printer_set_accepting_jobs (new_name, accepting, NULL);
+      printer_set_enabled (new_name, !printer_paused);
+      printer_set_shared (new_name, printer_shared);
+      printer_set_job_sheets (new_name, start_sheet, end_sheet);
+      printer_set_policy (new_name, op_policy, FALSE);
+      printer_set_policy (new_name, error_policy, TRUE);
+      printer_set_users (new_name, users_allowed, TRUE);
+      printer_set_users (new_name, users_denied, FALSE);
+      if (default_printer)
+        printer_set_default (new_name);
+
+      printer_delete (old_name);
+
+      result = TRUE;
+    }
+  else
+    printer_set_accepting_jobs (old_name, accepting, NULL);
+
+  cupsFreeDests (num_dests, dests);
+  if (sheets)
+    g_strfreev (sheets);
+  if (users_allowed)
+    g_strfreev (users_allowed);
+  if (users_denied)
+    g_strfreev (users_denied);
+
+  return result;
+}
+
+gboolean
+printer_set_location (const gchar *printer_name,
+                      const gchar *location)
+{
+  g_autoptr(GDBusConnection) bus = NULL;
+  g_autoptr(GVariant) output = NULL;
+  const gchar *ret_error;
+  g_autoptr(GError) error = NULL;
+
+  if (!printer_name || !location)
+    return TRUE;
+
+  bus = g_bus_get_sync (G_BUS_TYPE_SYSTEM, NULL, &error);
+  if (!bus)
+   {
+     g_warning ("Failed to get system bus: %s", error->message);
+     return TRUE;
+   }
+
+  output = g_dbus_connection_call_sync (bus,
+                                        MECHANISM_BUS,
+                                        "/",
+                                        MECHANISM_BUS,
+                                        "PrinterSetLocation",
+                                        g_variant_new ("(ss)", printer_name, location),
+                                        G_VARIANT_TYPE ("(s)"),
+                                        G_DBUS_CALL_FLAGS_NONE,
+                                        -1,
+                                        NULL,
+                                        &error);
+
+  if (output == NULL)
+    {
+      g_warning ("%s", error->message);
+      return FALSE;
+    }
+
+  g_variant_get (output, "(&s)", &ret_error);
+  if (ret_error[0] != '\0')
+    {
+      g_warning ("cups-pk-helper: setting of location for printer %s failed: %s", printer_name, ret_error);
+      return FALSE;
+    }
+
+  return TRUE;
+}
+
+gboolean
+printer_set_accepting_jobs (const gchar *printer_name,
+                            gboolean     accepting_jobs,
+                            const gchar *reason)
+{
+  g_autoptr(GDBusConnection) bus = NULL;
+  g_autoptr(GVariant) output = NULL;
+  const gchar *ret_error;
+  g_autoptr(GError) error = NULL;
+
+  if (!printer_name)
+    return TRUE;
+
+  bus = g_bus_get_sync (G_BUS_TYPE_SYSTEM, NULL, &error);
+  if (!bus)
+   {
+     g_warning ("Failed to get system bus: %s", error->message);
+     return TRUE;
+   }
+
+  output = g_dbus_connection_call_sync (bus,
+                                        MECHANISM_BUS,
+                                        "/",
+                                        MECHANISM_BUS,
+                                        "PrinterSetAcceptJobs",
+                                        g_variant_new ("(sbs)",
+                                                       printer_name,
+                                                       accepting_jobs,
+                                                       reason ? reason : ""),
+                                        G_VARIANT_TYPE ("(s)"),
+                                        G_DBUS_CALL_FLAGS_NONE,
+                                        -1,
+                                        NULL,
+                                        &error);
+
+  if (output == NULL)
+    {
+      g_warning ("%s", error->message);
+      return FALSE;
+    }
+
+  g_variant_get (output, "(&s)", &ret_error);
+  if (ret_error[0] != '\0')
+    {
+      g_warning ("cups-pk-helper: setting of acceptance of jobs for printer %s failed: %s", printer_name, ret_error);
+      return FALSE;
+    }
+
+  return TRUE;
+}
+
+gboolean
+printer_set_enabled (const gchar *printer_name,
+                     gboolean     enabled)
+{
+  g_autoptr(GDBusConnection) bus = NULL;
+  g_autoptr(GVariant) output = NULL;
+  const gchar *ret_error;
+  g_autoptr(GError) error = NULL;
+
+  if (!printer_name)
+    return TRUE;
+
+  bus = g_bus_get_sync (G_BUS_TYPE_SYSTEM, NULL, &error);
+  if (!bus)
+   {
+     g_warning ("Failed to get system bus: %s", error->message);
+     return TRUE;
+   }
+
+  output = g_dbus_connection_call_sync (bus,
+                                        MECHANISM_BUS,
+                                        "/",
+                                        MECHANISM_BUS,
+                                        "PrinterSetEnabled",
+                                        g_variant_new ("(sb)", printer_name, enabled),
+                                        G_VARIANT_TYPE ("(s)"),
+                                        G_DBUS_CALL_FLAGS_NONE,
+                                        -1,
+                                        NULL,
+                                        &error);
+
+  if (output == NULL)
+    {
+      g_warning ("%s", error->message);
+      return FALSE;
+    }
+
+  g_variant_get (output, "(&s)", &ret_error);
+  if (ret_error[0] != '\0')
+    {
+      g_warning ("cups-pk-helper: setting of enablement of printer %s failed: %s", printer_name, ret_error);
+      return FALSE;
+    }
+
+  return TRUE;
+}
+
+gboolean
+printer_delete (const gchar *printer_name)
+{
+  g_autoptr(GDBusConnection) bus = NULL;
+  g_autoptr(GVariant) output = NULL;
+  const gchar *ret_error;
+  g_autoptr(GError) error = NULL;
+
+  if (!printer_name)
+    return TRUE;
+
+  bus = g_bus_get_sync (G_BUS_TYPE_SYSTEM, NULL, &error);
+  if (!bus)
+   {
+     g_warning ("Failed to get system bus: %s", error->message);
+     return TRUE;
+   }
+
+  output = g_dbus_connection_call_sync (bus,
+                                        MECHANISM_BUS,
+                                        "/",
+                                        MECHANISM_BUS,
+                                        "PrinterDelete",
+                                        g_variant_new ("(s)", printer_name),
+                                        G_VARIANT_TYPE ("(s)"),
+                                        G_DBUS_CALL_FLAGS_NONE,
+                                        -1,
+                                        NULL,
+                                        &error);
+
+  if (output == NULL)
+    {
+      g_warning ("%s", error->message);
+      return FALSE;
+    }
+
+  g_variant_get (output, "(&s)", &ret_error);
+  if (ret_error[0] != '\0')
+    {
+      g_warning ("cups-pk-helper: removing of printer %s failed: %s", printer_name, ret_error);
+      return FALSE;
+    }
+
+  return TRUE;
+}
+
+gboolean
+printer_set_default (const gchar *printer_name)
+{
+  const char *cups_server;
+  g_autoptr(GError) error = NULL;
+
+  if (!printer_name)
+    return TRUE;
+
+  cups_server = cupsServer ();
+  if (g_ascii_strncasecmp (cups_server, "localhost", 9) == 0 ||
+      g_ascii_strncasecmp (cups_server, "127.0.0.1", 9) == 0 ||
+      g_ascii_strncasecmp (cups_server, "::1", 3) == 0 ||
+      cups_server[0] == '/')
+    {
+      g_autoptr(GDBusConnection) bus = NULL;
+      g_autoptr(GVariant) output = NULL;
+      const gchar *ret_error;
+
+      /* Clean .cups/lpoptions before setting
+       * default printer on local CUPS server.
+       */
+      set_local_default_printer (NULL);
+
+      bus = g_bus_get_sync (G_BUS_TYPE_SYSTEM, NULL, &error);
+      if (!bus)
+        {
+          g_warning ("Failed to get system bus: %s", error->message);
+          return FALSE;
+        }
+
+      output = g_dbus_connection_call_sync (bus,
+                                            MECHANISM_BUS,
+                                            "/",
+                                            MECHANISM_BUS,
+                                            "PrinterSetDefault",
+                                            g_variant_new ("(s)", printer_name),
+                                            G_VARIANT_TYPE ("(s)"),
+                                            G_DBUS_CALL_FLAGS_NONE,
+                                            -1,
+                                            NULL,
+                                            &error);
+
+      if (output == NULL)
+        {
+          g_warning ("%s", error->message);
+          return FALSE;
+        }
+
+      g_variant_get (output, "(&s)", &ret_error);
+      if (ret_error[0] != '\0')
+        {
+          g_warning ("cups-pk-helper: setting default printer to %s failed: %s", printer_name, ret_error);
+          return FALSE;
+        }
+
+      return TRUE;
+    }
+  else
+    /* Store default printer to .cups/lpoptions
+     * if we are connected to a remote CUPS server.
+     */
+    {
+      set_local_default_printer (printer_name);
+      return TRUE;
+    }
+}
+
+gboolean
+printer_set_shared (const gchar *printer_name,
+                    gboolean     shared)
+{
+  g_autoptr(GDBusConnection) bus = NULL;
+  g_autoptr(GVariant) output = NULL;
+  const gchar *ret_error;
+  g_autoptr(GError) error = NULL;
+
+  if (!printer_name)
+    return TRUE;
+
+  bus = g_bus_get_sync (G_BUS_TYPE_SYSTEM, NULL, &error);
+  if (!bus)
+   {
+     g_warning ("Failed to get system bus: %s", error->message);
+     return TRUE;
+   }
+
+  output = g_dbus_connection_call_sync (bus,
+                                        MECHANISM_BUS,
+                                        "/",
+                                        MECHANISM_BUS,
+                                        "PrinterSetShared",
+                                        g_variant_new ("(sb)", printer_name, shared),
+                                        G_VARIANT_TYPE ("(s)"),
+                                        G_DBUS_CALL_FLAGS_NONE,
+                                        -1,
+                                        NULL,
+                                        &error);
+
+  if (output == NULL)
+    {
+      g_warning ("%s", error->message);
+      return FALSE;
+    }
+
+  g_variant_get (output, "(&s)", &ret_error);
+  if (ret_error[0] != '\0')
+    {
+      g_warning ("cups-pk-helper: setting of sharing of printer %s failed: %s", printer_name, ret_error);
+      return FALSE;
+    }
+
+  return TRUE;
+}
+
+gboolean
+printer_set_job_sheets (const gchar *printer_name,
+                        const gchar *start_sheet,
+                        const gchar *end_sheet)
+{
+  g_autoptr(GDBusConnection) bus = NULL;
+  g_autoptr(GVariant) output = NULL;
+  const gchar *ret_error;
+  g_autoptr(GError) error = NULL;
+
+  if (!printer_name || !start_sheet || !end_sheet)
+    return TRUE;
+
+  bus = g_bus_get_sync (G_BUS_TYPE_SYSTEM, NULL, &error);
+  if (!bus)
+   {
+     g_warning ("Failed to get system bus: %s", error->message);
+     return TRUE;
+   }
+
+  output = g_dbus_connection_call_sync (bus,
+                                        MECHANISM_BUS,
+                                        "/",
+                                        MECHANISM_BUS,
+                                        "PrinterSetJobSheets",
+                                        g_variant_new ("(sss)", printer_name, start_sheet, end_sheet),
+                                        G_VARIANT_TYPE ("(s)"),
+                                        G_DBUS_CALL_FLAGS_NONE,
+                                        -1,
+                                        NULL,
+                                        &error);
+
+  if (output == NULL)
+    {
+      g_warning ("%s", error->message);
+      return FALSE;
+    }
+
+  g_variant_get (output, "(&s)", &ret_error);
+  if (ret_error[0] != '\0')
+    {
+      g_warning ("cups-pk-helper: setting of job sheets for printer %s failed: %s", printer_name, ret_error);
+      return FALSE;
+    }
+
+  return TRUE;
+}
+
+gboolean
+printer_set_policy (const gchar *printer_name,
+                    const gchar *policy,
+                    gboolean     error_policy)
+{
+  g_autoptr(GDBusConnection) bus = NULL;
+  g_autoptr(GVariant) output = NULL;
+  const gchar *ret_error;
+  g_autoptr(GError) error = NULL;
+
+  if (!printer_name || !policy)
+    return TRUE;
+
+  bus = g_bus_get_sync (G_BUS_TYPE_SYSTEM, NULL, &error);
+  if (!bus)
+   {
+     g_warning ("Failed to get system bus: %s", error->message);
+     return TRUE;
+   }
+
+  if (error_policy)
+    output = g_dbus_connection_call_sync (bus,
+                                          MECHANISM_BUS,
+                                          "/",
+                                          MECHANISM_BUS,
+                                          "PrinterSetErrorPolicy",
+                                          g_variant_new ("(ss)", printer_name, policy),
+                                          G_VARIANT_TYPE ("(s)"),
+                                          G_DBUS_CALL_FLAGS_NONE,
+                                          -1,
+                                          NULL,
+                                          &error);
+  else
+    output = g_dbus_connection_call_sync (bus,
+                                          MECHANISM_BUS,
+                                          "/",
+                                          MECHANISM_BUS,
+                                          "PrinterSetOpPolicy",
+                                          g_variant_new ("(ss)", printer_name, policy),
+                                          G_VARIANT_TYPE ("(s)"),
+                                          G_DBUS_CALL_FLAGS_NONE,
+                                          -1,
+                                          NULL,
+                                          &error);
+
+  if (output == NULL)
+    {
+      g_warning ("%s", error->message);
+      return FALSE;
+    }
+
+  g_variant_get (output, "(&s)", &ret_error);
+  if (ret_error[0] != '\0')
+    {
+      g_warning ("cups-pk-helper: setting of a policy for printer %s failed: %s", printer_name, ret_error);
+      return FALSE;
+    }
+
+  return TRUE;
+}
+
+gboolean
+printer_set_users (const gchar  *printer_name,
+                   gchar       **users,
+                   gboolean      allowed)
+{
+  g_autoptr(GDBusConnection) bus = NULL;
+  GVariantBuilder     array_builder;
+  gint                i;
+  g_autoptr(GVariant) output = NULL;
+  const gchar        *ret_error;
+  g_autoptr(GError)   error = NULL;
+
+  if (!printer_name || !users)
+    return TRUE;
+  
+  bus = g_bus_get_sync (G_BUS_TYPE_SYSTEM, NULL, &error);
+  if (!bus)
+   {
+     g_warning ("Failed to get system bus: %s", error->message);
+     return TRUE;
+   }
+
+  g_variant_builder_init (&array_builder, G_VARIANT_TYPE ("as"));
+  for (i = 0; users[i]; i++)
+    g_variant_builder_add (&array_builder, "s", users[i]);
+
+  if (allowed)
+    output = g_dbus_connection_call_sync (bus,
+                                          MECHANISM_BUS,
+                                          "/",
+                                          MECHANISM_BUS,
+                                          "PrinterSetUsersAllowed",
+                                          g_variant_new ("(sas)", printer_name, &array_builder),
+                                          G_VARIANT_TYPE ("(s)"),
+                                          G_DBUS_CALL_FLAGS_NONE,
+                                          -1,
+                                          NULL,
+                                          &error);
+  else
+    output = g_dbus_connection_call_sync (bus,
+                                          MECHANISM_BUS,
+                                          "/",
+                                          MECHANISM_BUS,
+                                          "PrinterSetUsersDenied",
+                                          g_variant_new ("(sas)", printer_name, &array_builder),
+                                          G_VARIANT_TYPE ("(s)"),
+                                          G_DBUS_CALL_FLAGS_NONE,
+                                          -1,
+                                          NULL,
+                                          &error);
+
+  if (output == NULL)
+    {
+      g_warning ("%s", error->message);
+      return FALSE;
+    }
+
+  g_variant_get (output, "(&s)", &ret_error);
+  if (ret_error[0] != '\0')
+    {
+      g_warning ("cups-pk-helper: setting of access list for printer %s failed: %s", printer_name, ret_error);
+      return FALSE;
+    }
+
+  return TRUE;
+}
+
+gboolean
+class_add_printer (const gchar *class_name,
+                   const gchar *printer_name)
+{
+  g_autoptr(GDBusConnection) bus = NULL;
+  g_autoptr(GVariant) output = NULL;
+  const gchar *ret_error;
+  g_autoptr(GError) error = NULL;
+
+  if (!class_name || !printer_name)
+    return TRUE;
+
+  bus = g_bus_get_sync (G_BUS_TYPE_SYSTEM, NULL, &error);
+  if (!bus)
+   {
+     g_warning ("Failed to get system bus: %s", error->message);
+     return TRUE;
+   }
+
+  output = g_dbus_connection_call_sync (bus,
+                                        MECHANISM_BUS,
+                                        "/",
+                                        MECHANISM_BUS,
+                                        "ClassAddPrinter",
+                                        g_variant_new ("(ss)", class_name, printer_name),
+                                        G_VARIANT_TYPE ("(s)"),
+                                        G_DBUS_CALL_FLAGS_NONE,
+                                        -1,
+                                        NULL,
+                                        &error);
+
+  if (output == NULL)
+    {
+      g_warning ("%s", error->message);
+      return FALSE;
+    }
+
+  g_variant_get (output, "(&s)", &ret_error);
+  if (ret_error[0] != '\0')
+    {
+      g_warning ("cups-pk-helper: adding of printer %s to class %s failed: %s", printer_name, class_name, ret_error);
+      return FALSE;
+    }
+
+  return TRUE;
+}
+
+gboolean
+printer_is_local (cups_ptype_t  printer_type,
+                  const gchar  *device_uri)
+{
+  gboolean result = TRUE;
+  char     scheme[HTTP_MAX_URI];
+  char     username[HTTP_MAX_URI];
+  char     hostname[HTTP_MAX_URI];
+  char     resource[HTTP_MAX_URI];
+  int      port;
+
+  if (printer_type &
+      (CUPS_PRINTER_DISCOVERED |
+       CUPS_PRINTER_REMOTE |
+       CUPS_PRINTER_IMPLICIT))
+    result = FALSE;
+
+  if (device_uri == NULL || !result)
+    return result;
+
+  httpSeparateURI (HTTP_URI_CODING_ALL, device_uri,
+		   scheme, sizeof (scheme), 
+		   username, sizeof (username),
+		   hostname, sizeof (hostname),
+		   &port,
+		   resource, sizeof (resource));
+
+  if (g_str_equal (scheme, "ipp") ||
+      g_str_equal (scheme, "smb") ||
+      g_str_equal (scheme, "socket") ||
+      g_str_equal (scheme, "lpd"))
+    result = FALSE;
+
+  return result;
+}
+
+gchar*
+printer_get_hostname (cups_ptype_t  printer_type,
+                      const gchar  *device_uri,
+                      const gchar  *printer_uri)
+{
+  gboolean  local = TRUE;
+  gchar    *result = NULL;
+  char      scheme[HTTP_MAX_URI];
+  char      username[HTTP_MAX_URI];
+  char      hostname[HTTP_MAX_URI];
+  char      resource[HTTP_MAX_URI];
+  int       port;
+
+  if (device_uri == NULL)
+    return result;
+
+  if (printer_type & (CUPS_PRINTER_DISCOVERED |
+                      CUPS_PRINTER_REMOTE |
+                      CUPS_PRINTER_IMPLICIT))
+    {
+      if (printer_uri)
+        {
+          httpSeparateURI (HTTP_URI_CODING_ALL, printer_uri,
+                           scheme, sizeof (scheme),
+                           username, sizeof (username),
+                           hostname, sizeof (hostname),
+                           &port,
+                           resource, sizeof (resource));
+
+          if (hostname[0] != '\0')
+            result = g_strdup (hostname);
+        }
+
+      local = FALSE;
+    }
+
+  if (result == NULL && device_uri)
+    {
+      httpSeparateURI (HTTP_URI_CODING_ALL, device_uri,
+                       scheme, sizeof (scheme),
+                       username, sizeof (username),
+                       hostname, sizeof (hostname),
+                       &port,
+                       resource, sizeof (resource));
+
+      if (g_str_equal (scheme, "ipp") ||
+          g_str_equal (scheme, "smb") ||
+          g_str_equal (scheme, "socket") ||
+          g_str_equal (scheme, "lpd"))
+        {
+          if (hostname[0] != '\0')
+            result = g_strdup (hostname);
+
+          local = FALSE;
+        }
+    }
+
+  if (local)
+    result = g_strdup ("localhost");
+
+  return result;
+}
+
+/* Returns default page size for current locale */
+const gchar *
+get_page_size_from_locale (void)
+{
+  if (g_str_equal (gtk_paper_size_get_default (), GTK_PAPER_NAME_LETTER))
+    return "Letter";
+  else
+    return "A4";
+}
+
+typedef struct
+{
+  gchar        *printer_name;
+  gchar       **attributes_names;
+  GHashTable   *result;
+  GIACallback   callback;
+  gpointer      user_data;
+  GMainContext *context;
+} GIAData;
+
+static GIAData *
+gia_data_new (const gchar *printer_name, gchar **attributes_names, GIACallback callback, gpointer user_data)
+{
+  GIAData *data;
+
+  data = g_new0 (GIAData, 1);
+  data->printer_name = g_strdup (printer_name);
+  data->attributes_names = g_strdupv (attributes_names);
+  data->callback = callback;
+  data->user_data = user_data;
+  data->context = g_main_context_ref_thread_default ();
+
+  return data;
+}
+
+static void
+gia_data_free (GIAData *data)
+{
+  g_free (data->printer_name);
+  if (data->attributes_names)
+    g_strfreev (data->attributes_names);
+  if (data->result)
+    g_hash_table_unref (data->result);
+  if (data->context)
+    g_main_context_unref (data->context);
+  g_free (data);
+}
+
+static gboolean
+get_ipp_attributes_idle_cb (gpointer user_data)
+{
+  GIAData *data = (GIAData *) user_data;
+
+  data->callback (data->result, data->user_data);
+
+  return FALSE;
+}
+
+static void
+get_ipp_attributes_cb (gpointer user_data)
+{
+  GIAData *data = user_data;
+  g_autoptr(GSource) idle_source = NULL;
+
+  idle_source = g_idle_source_new ();
+  g_source_set_callback (idle_source,
+                         get_ipp_attributes_idle_cb,
+                         data,
+                         (GDestroyNotify) gia_data_free);
+  g_source_attach (idle_source, data->context);
+}
+
+static void
+ipp_attribute_free2 (gpointer attr)
+{
+  IPPAttribute *attribute = (IPPAttribute *) attr;
+  ipp_attribute_free (attribute);
+}
+
+static gpointer
+get_ipp_attributes_func (gpointer user_data)
+{
+  ipp_attribute_t  *attr = NULL;
+  GIAData          *data = user_data;
+  ipp_t            *request;
+  ipp_t            *response = NULL;
+  g_autofree gchar *printer_uri = NULL;
+  char            **requested_attrs = NULL;
+  gint              i, j, length = 0;
+
+  printer_uri = g_strdup_printf ("ipp://localhost/printers/%s", data->printer_name);
+
+  if (data->attributes_names)
+    {
+      length = g_strv_length (data->attributes_names);
+
+      requested_attrs = g_new0 (char *, length);
+      for (i = 0; data->attributes_names[i]; i++)
+        requested_attrs[i] = g_strdup (data->attributes_names[i]);
+
+      request = ippNewRequest (IPP_GET_PRINTER_ATTRIBUTES);
+      ippAddString (request, IPP_TAG_OPERATION, IPP_TAG_URI,
+                    "printer-uri", NULL, printer_uri);
+      ippAddStrings (request, IPP_TAG_OPERATION, IPP_TAG_KEYWORD,
+                     "requested-attributes", length, NULL, (const char **) requested_attrs);
+      response = cupsDoRequest (CUPS_HTTP_DEFAULT, request, "/");
+    }
+
+  if (response)
+    {
+      if (ippGetStatusCode (response) <= IPP_OK_CONFLICT)
+        {
+          for (j = 0; j < length; j++)
+            {
+              attr = ippFindAttribute (response, requested_attrs[j], IPP_TAG_ZERO);
+              if (attr && ippGetCount (attr) > 0 && ippGetValueTag (attr) != IPP_TAG_NOVALUE)
+                {
+                  IPPAttribute *attribute;
+
+                  attribute = g_new0 (IPPAttribute, 1);
+                  attribute->attribute_name = g_strdup (requested_attrs[j]);
+                  attribute->attribute_values = g_new0 (IPPAttributeValue, ippGetCount (attr));
+                  attribute->num_of_values = ippGetCount (attr);
+
+                  if (ippGetValueTag (attr) == IPP_TAG_INTEGER ||
+                      ippGetValueTag (attr) == IPP_TAG_ENUM)
+                    {
+                      attribute->attribute_type = IPP_ATTRIBUTE_TYPE_INTEGER;
+
+                      for (i = 0; i < ippGetCount (attr); i++)
+                        attribute->attribute_values[i].integer_value = ippGetInteger (attr, i);
+                    }
+                  else if (ippGetValueTag (attr) == IPP_TAG_NAME ||
+                           ippGetValueTag (attr) == IPP_TAG_STRING ||
+                           ippGetValueTag (attr) == IPP_TAG_TEXT ||
+                           ippGetValueTag (attr) == IPP_TAG_URI ||
+                           ippGetValueTag (attr) == IPP_TAG_KEYWORD ||
+                           ippGetValueTag (attr) == IPP_TAG_URISCHEME)
+                    {
+                      attribute->attribute_type = IPP_ATTRIBUTE_TYPE_STRING;
+
+                      for (i = 0; i < ippGetCount (attr); i++)
+                        attribute->attribute_values[i].string_value = g_strdup (ippGetString (attr, i, NULL));
+                    }
+                  else if (ippGetValueTag (attr) == IPP_TAG_RANGE)
+                    {
+                      attribute->attribute_type = IPP_ATTRIBUTE_TYPE_RANGE;
+
+                      for (i = 0; i < ippGetCount (attr); i++)
+                        {
+                          attribute->attribute_values[i].lower_range =
+                            ippGetRange (attr, i, &(attribute->attribute_values[i].upper_range));
+                        }
+                    }
+                  else if (ippGetValueTag (attr) == IPP_TAG_BOOLEAN)
+                    {
+                      attribute->attribute_type = IPP_ATTRIBUTE_TYPE_BOOLEAN;
+
+                      for (i = 0; i < ippGetCount (attr); i++)
+                        attribute->attribute_values[i].boolean_value = ippGetBoolean (attr, i);
+                    }
+
+                  if (!data->result)
+                    data->result = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, ipp_attribute_free2);
+
+                  g_hash_table_insert (data->result, g_strdup (requested_attrs[j]), attribute);
+                }
+            }
+        }
+
+      ippDelete (response);
+    }
+
+
+  for (i = 0; i < length; i++)
+    g_free (requested_attrs[i]);
+  g_free (requested_attrs);
+
+  get_ipp_attributes_cb (data);
+
+  return NULL;
+}
+
+void
+get_ipp_attributes_async (const gchar  *printer_name,
+                          gchar       **attributes_names,
+                          GIACallback   callback,
+                          gpointer      user_data)
+{
+  GIAData          *data;
+  g_autoptr(GThread) thread = NULL;
+  g_autoptr(GError) error = NULL;
+
+  data = gia_data_new (printer_name, attributes_names, callback, user_data);
+
+  thread = g_thread_try_new ("get-ipp-attributes",
+                             get_ipp_attributes_func,
+                             data,
+                             &error);
+
+  if (!thread)
+    {
+      g_warning ("%s", error->message);
+      callback (NULL, user_data);
+
+      gia_data_free (data);
+    }
+}
+
+IPPAttribute *
+ipp_attribute_copy (IPPAttribute *attr)
+{
+  IPPAttribute *result = NULL;
+  gint          i;
+
+  if (attr)
+    {
+      result = g_new0 (IPPAttribute, 1);
+
+      *result = *attr;
+      result->attribute_name = g_strdup (attr->attribute_name);
+      result->attribute_values = g_new0 (IPPAttributeValue, attr->num_of_values);
+      for (i = 0; i < attr->num_of_values; i++)
+        {
+          result->attribute_values[i] = attr->attribute_values[i];
+          if (attr->attribute_values[i].string_value)
+            result->attribute_values[i].string_value = g_strdup (attr->attribute_values[i].string_value);
+        }
+    }
+
+  return result;
+}
+
+void
+ipp_attribute_free (IPPAttribute *attr)
+{
+  gint i;
+
+  if (attr)
+    {
+      for (i = 0; i < attr->num_of_values; i++)
+        g_free (attr->attribute_values[i].string_value);
+
+      g_free (attr->attribute_values);
+      g_free (attr->attribute_name);
+      g_free (attr);
+    }
+}
+
+typedef struct
+{
+  gchar        *printer_name;
+  gchar        *ppd_copy;
+  GCancellable *cancellable;
+  PSPCallback   callback;
+  gpointer      user_data;
+} PSPData;
+
+static PSPData *
+psp_data_new (const gchar *printer_name, const gchar *ppd_copy, GCancellable *cancellable, PSPCallback callback, gpointer user_data)
+{
+  PSPData *data;
+
+  data = g_new0 (PSPData, 1);
+  data->printer_name = g_strdup (printer_name);
+  data->ppd_copy = g_strdup (ppd_copy);
+  if (cancellable)
+    data->cancellable = g_object_ref (cancellable);
+  data->callback = callback;
+  data->user_data = user_data;
+  return data;
+}
+
+static void
+psp_data_free (PSPData *data)
+{
+  g_free (data->printer_name);
+  if (data->ppd_copy != NULL)
+    {
+      g_unlink (data->ppd_copy);
+      g_free (data->ppd_copy);
+    }
+  g_clear_object (&data->cancellable);
+  g_free (data);
+}
+
+G_DEFINE_AUTOPTR_CLEANUP_FUNC (PSPData, psp_data_free)
+
+static void
+printer_set_ppd_async_dbus_cb (GObject      *source_object,
+                               GAsyncResult *res,
+                               gpointer      user_data)
+{
+  g_autoptr(GVariant) output = NULL;
+  gboolean            result = FALSE;
+  g_autoptr(PSPData)  data = user_data;
+  g_autoptr(GError)   error = NULL;
+
+  output = g_dbus_connection_call_finish (G_DBUS_CONNECTION (source_object),
+                                          res,
+                                          &error);
+
+  if (output)
+    {
+      const gchar *ret_error;
+
+      g_variant_get (output, "(&s)", &ret_error);
+      if (ret_error[0] != '\0')
+        g_warning ("cups-pk-helper: setting of driver for printer %s failed: %s", data->printer_name, ret_error);
+      else
+        result = TRUE;
+    }
+  else
+    {
+      if (!g_error_matches (error, G_IO_ERROR, G_IO_ERROR_CANCELLED))
+        g_warning ("%s", error->message);
+    }
+
+  /* Don't call callback if cancelled */
+  if (!data->cancellable ||
+      !g_cancellable_is_cancelled (data->cancellable))
+    data->callback (data->printer_name,
+                    result,
+                    data->user_data);
+}
+
+/*
+ * Set ppd for given printer.
+ * Don't use this for classes, just for printers.
+ */
+void
+printer_set_ppd_async (const gchar  *printer_name,
+                       const gchar  *ppd_name,
+                       GCancellable *cancellable,
+                       PSPCallback   callback,
+                       gpointer      user_data)
+{
+  g_autoptr(GDBusConnection) bus = NULL;
+  g_autoptr(GError) error = NULL;
+
+  if (printer_name == NULL ||
+      printer_name[0] == '\0')
+    {
+      callback (printer_name, FALSE, user_data);
+      return;
+    }
+
+  bus = g_bus_get_sync (G_BUS_TYPE_SYSTEM, NULL, &error);
+  if (!bus)
+    {
+      g_warning ("Failed to get system bus: %s", error->message);
+      callback (printer_name, FALSE, user_data);
+      return;
+    }
+
+  g_dbus_connection_call (bus,
+                          MECHANISM_BUS,
+                          "/",
+                          MECHANISM_BUS,
+                          "PrinterAdd",
+                          g_variant_new ("(sssss)",
+                                         printer_name,
+                                         "",
+                                         ppd_name,
+                                         "",
+                                         ""),
+                          G_VARIANT_TYPE ("(s)"),
+                          G_DBUS_CALL_FLAGS_NONE,
+                          -1,
+                          cancellable,
+                          printer_set_ppd_async_dbus_cb,
+                          psp_data_new (printer_name, NULL, cancellable, callback, user_data));
+}
+
+static void
+printer_set_ppd_file_async_scb (GObject      *source_object,
+                                GAsyncResult *res,
+                                gpointer      user_data)
+{
+  g_autoptr(GDBusConnection) bus = NULL;
+  gboolean          success;
+  g_autoptr(PSPData) data = user_data;
+  g_autoptr(GError) error = NULL;
+
+  success = g_file_copy_finish (G_FILE (source_object),
+                                res,
+                                &error);
+
+  if (!success)
+    {
+      g_warning ("%s", error->message);
+      data->callback (data->printer_name, FALSE, data->user_data);
+      return;
+    }
+
+  bus = g_bus_get_sync (G_BUS_TYPE_SYSTEM, NULL, &error);
+  if (!bus)
+    {
+      g_warning ("Failed to get system bus: %s", error->message);
+      data->callback (data->printer_name, FALSE, data->user_data);
+      return;
+    }
+
+  g_dbus_connection_call (bus,
+                          MECHANISM_BUS,
+                          "/",
+                          MECHANISM_BUS,
+                          "PrinterAddWithPpdFile",
+                          g_variant_new ("(sssss)",
+                                         data->printer_name,
+                                         "",
+                                         data->ppd_copy,
+                                         "",
+                                         ""),
+                          G_VARIANT_TYPE ("(s)"),
+                          G_DBUS_CALL_FLAGS_NONE,
+                          -1,
+                          data->cancellable,
+                          printer_set_ppd_async_dbus_cb,
+                          data);
+   g_steal_pointer (&data);
+}
+
+/*
+ * Set ppd for given printer.
+ * Don't use this for classes, just for printers.
+ */
+void
+printer_set_ppd_file_async (const gchar  *printer_name,
+                            const gchar  *ppd_filename,
+                            GCancellable *cancellable,
+                            PSPCallback   callback,
+                            gpointer      user_data)
+{
+  g_autoptr(GFileIOStream) stream = NULL;
+  g_autoptr(GFile) source_ppd_file = NULL;
+  g_autoptr(GFile) destination_ppd_file = NULL;
+
+  if (printer_name == NULL ||
+      printer_name[0] == '\0')
+    {
+      callback (printer_name, FALSE, user_data);
+      return;
+    }
+
+  /*
+   * We need to copy the PPD to temp directory at first.
+   * This is needed because of SELinux.
+   */
+  source_ppd_file = g_file_new_for_path (ppd_filename);
+  destination_ppd_file = g_file_new_tmp ("g-c-c-XXXXXX.ppd", &stream, NULL);
+
+  g_file_copy_async (source_ppd_file,
+                     destination_ppd_file,
+                     G_FILE_COPY_OVERWRITE,
+                     G_PRIORITY_DEFAULT,
+                     cancellable,
+                     NULL,
+                     NULL,
+                     printer_set_ppd_file_async_scb,
+                     psp_data_new (printer_name, g_file_get_path (destination_ppd_file), cancellable, callback, user_data));
+}
+
+typedef void (*GPACallback) (gchar    **attribute_values,
+                             gpointer   user_data);
+
+typedef struct
+{
+  gchar        **ppds_names;
+  gchar         *attribute_name;
+  gchar        **result;
+  GPACallback    callback;
+  gpointer       user_data;
+  GMainContext  *context;
+} GPAData;
+
+static GPAData *
+gpa_data_new (gchar **ppds_names, gchar *attribute_name, GPACallback callback, gpointer user_data)
+{
+  GPAData *data;
+
+  data = g_new0 (GPAData, 1);
+  data->ppds_names = g_strdupv (ppds_names);
+  data->attribute_name = g_strdup (attribute_name);
+  data->callback = callback;
+  data->user_data = user_data;
+  data->context = g_main_context_ref_thread_default ();
+
+  return data;
+}
+
+static void
+gpa_data_free (GPAData *data)
+{
+  g_free (data->attribute_name);
+  g_strfreev (data->ppds_names);
+  if (data->result != NULL)
+    g_strfreev (data->result);
+  if (data->context)
+    g_main_context_unref (data->context);
+  g_free (data);
+}
+
+static gboolean
+get_ppds_attribute_idle_cb (gpointer user_data)
+{
+  GPAData *data = (GPAData *) user_data;
+
+  data->callback (data->result, data->user_data);
+
+  return FALSE;
+}
+
+static void
+get_ppds_attribute_cb (gpointer user_data)
+{
+  GPAData *data = (GPAData *) user_data;
+  g_autoptr(GSource) idle_source = NULL;
+
+  idle_source = g_idle_source_new ();
+  g_source_set_callback (idle_source,
+                         get_ppds_attribute_idle_cb,
+                         data,
+                         (GDestroyNotify) gpa_data_free);
+  g_source_attach (idle_source, data->context);
+}
+
+static gpointer
+get_ppds_attribute_func (gpointer user_data)
+{
+  ppd_file_t  *ppd_file;
+  ppd_attr_t  *ppd_attr;
+  GPAData     *data = user_data;
+  gint         i;
+
+  data->result = g_new0 (gchar *, g_strv_length (data->ppds_names) + 1);
+  for (i = 0; data->ppds_names[i]; i++)
+    {
+      g_autofree gchar *ppd_filename = g_strdup (cupsGetServerPPD (CUPS_HTTP_DEFAULT, data->ppds_names[i]));
+      if (ppd_filename)
+        {
+          ppd_file = ppdOpenFile (ppd_filename);
+          if (ppd_file)
+            {
+              ppd_attr = ppdFindAttr (ppd_file, data->attribute_name, NULL);
+              if (ppd_attr != NULL)
+                data->result[i] = g_strdup (ppd_attr->value);
+
+              ppdClose (ppd_file);
+            }
+
+          g_unlink (ppd_filename);
+        }
+    }
+
+  get_ppds_attribute_cb (data);
+
+  return NULL;
+}
+
+/*
+ * Get values of requested PPD attribute for given PPDs.
+ */
+static void
+get_ppds_attribute_async (gchar       **ppds_names,
+                          gchar        *attribute_name,
+                          GPACallback   callback,
+                          gpointer      user_data)
+{
+  GPAData          *data;
+  g_autoptr(GThread) thread = NULL;
+  g_autoptr(GError) error = NULL;
+
+  if (!ppds_names || !attribute_name)
+    {
+      callback (NULL, user_data);
+      return;
+    }
+
+  data = gpa_data_new (ppds_names, attribute_name, callback, user_data);
+
+  thread = g_thread_try_new ("get-ppds-attribute",
+                             get_ppds_attribute_func,
+                             data,
+                             &error);
+
+  if (!thread)
+    {
+      g_warning ("%s", error->message);
+      callback (NULL, user_data);
+
+      gpa_data_free (data);
+    }
+}
+
+
+
+typedef void (*GDACallback) (gchar    *device_id,
+                             gchar    *device_make_and_model,
+                             gchar    *device_uri,
+                             gpointer  user_data);
+
+typedef struct
+{
+  gchar        *printer_name;
+  gchar        *device_uri;
+  GList        *backend_list;
+  GCancellable *cancellable;
+  GDACallback   callback;
+  gpointer      user_data;
+} GDAData;
+
+static GDAData *
+gda_data_new (const gchar *printer_name, GCancellable *cancellable, GDACallback callback, gpointer user_data)
+{
+  GDAData *data;
+
+  data = g_new0 (GDAData, 1);
+  data->printer_name = g_strdup (printer_name);
+  if (cancellable)
+    data->cancellable = g_object_ref (cancellable);
+  data->callback = callback;
+  data->user_data = user_data;
+
+  return data;
+}
+
+static void
+gda_data_free (GDAData *data)
+{
+  g_free (data->printer_name);
+  g_free (data->device_uri);
+  g_list_free_full(data->backend_list, g_free);
+  g_clear_object (&data->cancellable);
+  g_free (data);
+}
+
+G_DEFINE_AUTOPTR_CLEANUP_FUNC (GDAData, gda_data_free)
+
+typedef struct
+{
+  gchar         *printer_name;
+  gint           count;
+  PPDName      **result;
+  GCancellable  *cancellable;
+  GPNCallback    callback;
+  gpointer       user_data;
+} GPNData;
+
+static GPNData *
+gpn_data_new (const gchar *printer_name, gint count, GCancellable *cancellable, GPNCallback callback, gpointer user_data)
+{
+  GPNData *data;
+
+  data = g_new0 (GPNData, 1);
+  data->printer_name = g_strdup (printer_name);
+  data->count = count;
+  if (cancellable)
+    data->cancellable = g_object_ref (cancellable);
+  data->callback = callback;
+  data->user_data = user_data;
+
+  return data;
+}
+
+static void
+gpn_data_free (GPNData *data)
+{
+  g_free (data->printer_name);
+  if (data->result != NULL)
+    {
+      for (int i = 0; data->result[i]; i++)
+        {
+           g_free (data->result[i]->ppd_name);
+           g_free (data->result[i]->ppd_display_name);
+           g_free (data->result[i]);
+        }
+      g_free (data->result);
+    }
+  g_clear_object (&data->cancellable);
+  g_free (data);
+}
+
+G_DEFINE_AUTOPTR_CLEANUP_FUNC (GPNData, gpn_data_free)
+
+static void
+get_ppd_names_async_cb (gchar    **attribute_values,
+                        gpointer   user_data)
+{
+  g_autoptr(GPNData) data = user_data;
+  gint     i;
+
+  if (g_cancellable_is_cancelled (data->cancellable))
+    {
+      data->callback (NULL,
+                      data->printer_name,
+                      TRUE,
+                      data->user_data);
+      return;
+    }
+
+  if (attribute_values)
+    {
+      for (i = 0; attribute_values[i]; i++)
+        data->result[i]->ppd_display_name = g_strdup (attribute_values[i]);
+    }
+
+  data->callback (data->result,
+                  data->printer_name,
+                  FALSE,
+                  data->user_data);
+}
+
+static void
+get_ppd_names_async_dbus_scb (GObject      *source_object,
+                              GAsyncResult *res,
+                              gpointer      user_data)
+{
+  g_autoptr(GVariant) output = NULL;
+  PPDName            *ppd_item;
+  PPDName           **result = NULL;
+  g_autoptr(GPNData)  data = user_data;
+  g_autoptr(GError)   error = NULL;
+  GList              *driver_list = NULL;
+  GList              *iter;
+  gint                i, j, n = 0;
+  static const char * const match_levels[] = {
+             "exact-cmd",
+             "exact",
+             "close",
+             "generic",
+             "none"};
+
+  output = g_dbus_connection_call_finish (G_DBUS_CONNECTION (source_object),
+                                          res,
+                                          &error);
+
+  if (output)
+    {
+      g_autoptr(GVariant) array = NULL;
+
+      g_variant_get (output, "(@a(ss))",
+                     &array);
+
+      for (j = 0; j < G_N_ELEMENTS (match_levels) && n < data->count; j++)
+        {
+          g_autoptr(GVariantIter) iter = NULL;
+          const gchar *driver, *match;
+
+          g_variant_get (array,
+                         "a(ss)",
+                         &iter);
+
+          while (g_variant_iter_next (iter, "(&s&s)", &driver, &match))
+            {
+              if (g_str_equal (match, match_levels[j]) && n < data->count)
+                {
+                  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;
+
+                  driver_list = g_list_append (driver_list, ppd_item);
+
+                  n++;
+                }
+            }
+        }
+    }
+  else
+    {
+      if (!g_error_matches (error, G_IO_ERROR, G_IO_ERROR_CANCELLED))
+        g_warning ("%s", error->message);
+    }
+
+  if (n > 0)
+    {
+      result = g_new0 (PPDName *, n + 1);
+      i = 0;
+      for (iter = driver_list; iter; iter = iter->next)
+        {
+          result[i] = iter->data;
+          i++;
+        }
+    }
+
+  if (result)
+    {
+      g_auto(GStrv) ppds_names = NULL;
+
+      data->result = result;
+
+      ppds_names = g_new0 (gchar *, n + 1);
+      for (i = 0; i < n; i++)
+        ppds_names[i] = g_strdup (result[i]->ppd_name);
+
+      get_ppds_attribute_async (ppds_names,
+                                "NickName",
+                                get_ppd_names_async_cb,
+                                data);
+      g_steal_pointer (&data);
+    }
+  else
+    {
+      data->callback (NULL,
+                      data->printer_name,
+                      g_cancellable_is_cancelled (data->cancellable),
+                      data->user_data);
+    }
+}
+
+static void
+get_device_attributes_cb (gchar    *device_id,
+                          gchar    *device_make_and_model,
+                          gchar    *device_uri,
+                          gpointer  user_data)
+{
+  g_autoptr(GDBusConnection) bus = NULL;
+  g_autoptr(GError) error = NULL;
+  g_autoptr(GPNData) data = user_data;
+
+  if (g_cancellable_is_cancelled (data->cancellable))
+    {
+      data->callback (NULL,
+                      data->printer_name,
+                      TRUE,
+                      data->user_data);
+      return;
+    }
+
+  if (!device_id || !device_make_and_model || !device_uri)
+    {
+      data->callback (NULL,
+                      data->printer_name,
+                      FALSE,
+                      data->user_data);
+      return;
+    }
+
+  bus = g_bus_get_sync (G_BUS_TYPE_SESSION, NULL, &error);
+  if (!bus)
+    {
+      g_warning ("Failed to get system bus: %s", error->message);
+      data->callback (NULL,
+                      data->printer_name,
+                      FALSE,
+                      data->user_data);
+      return;
+    }
+
+  g_dbus_connection_call (bus,
+                          SCP_BUS,
+                          SCP_PATH,
+                          SCP_IFACE,
+                          "GetBestDrivers",
+                          g_variant_new ("(sss)",
+                                         device_id,
+                                         device_make_and_model,
+                                         device_uri),
+                          G_VARIANT_TYPE ("(a(ss))"),
+                          G_DBUS_CALL_FLAGS_NONE,
+                          DBUS_TIMEOUT_LONG,
+                          data->cancellable,
+                          get_ppd_names_async_dbus_scb,
+                          data);
+  g_steal_pointer (&data);
+}
+
+/*
+ * Special item for the list of backends. It represents
+ * backends not present in the list itself.
+ */
+#define OTHER_BACKENDS "other-backends"
+
+/*
+ * List of CUPS backends sorted according to their speed,
+ * the fastest is the first one. The last item represents
+ * backends not present in the list.
+ */
+const gchar *cups_backends[] = {
+  "usb",
+  "socket",
+  "serial",
+  "parallel",
+  "lpd",
+  "ipp",
+  "hp",
+  "dnssd",
+  "snmp",
+  "bluetooth",
+  "beh",
+  "ncp",
+  "hpfax",
+  OTHER_BACKENDS
+};
+
+static GList *
+create_backends_list ()
+{
+  GList *list = NULL;
+  gint   i;
+
+  for (i = 0; i < G_N_ELEMENTS (cups_backends); i++)
+    list = g_list_prepend (list, g_strdup (cups_backends[i]));
+  list = g_list_reverse (list);
+
+  return list;
+}
+
+static GVariantBuilder *
+create_other_backends_array ()
+{
+  GVariantBuilder *builder;
+  gint             i;
+
+  builder = g_variant_builder_new (G_VARIANT_TYPE ("as"));
+  for (i = 0; i < G_N_ELEMENTS (cups_backends) - 1; i++)
+    g_variant_builder_add (builder, "s", cups_backends[i]);
+
+  return builder;
+}
+
+static void
+get_device_attributes_async_dbus_cb (GObject      *source_object,
+                                     GAsyncResult *res,
+                                     gpointer      user_data)
+
+{
+  g_autoptr(GVariant) output = NULL;
+  g_autoptr(GDAData)  data = user_data;
+  g_autoptr(GError)   error = NULL;
+  gchar              *device_id = NULL;
+  gchar              *device_make_and_model = NULL;
+
+  output = g_dbus_connection_call_finish (G_DBUS_CONNECTION (source_object),
+                                          res,
+                                          &error);
+
+  if (output)
+    {
+      const gchar *ret_error;
+      g_autoptr(GVariant) devices_variant = NULL;
+      gint index = -1;
+
+      g_variant_get (output, "(&s@a{ss})",
+                     &ret_error,
+                     &devices_variant);
+
+      if (ret_error[0] != '\0')
+        {
+          g_warning ("cups-pk-helper: getting of attributes for printer %s failed: %s", data->printer_name, ret_error);
+        }
+
+      if (data->device_uri)
+        {
+          g_autoptr(GVariantIter) iter = NULL;
+          const gchar *key, *value;
+          g_autofree gchar *suffix = NULL;
+
+          g_variant_get (devices_variant,
+                         "a{ss}",
+                         &iter);
+
+          while (g_variant_iter_next (iter, "{&s&s}", &key, &value))
+            {
+              if (g_str_equal (value, data->device_uri))
+                {
+                  gchar *number = g_strrstr (key, ":");
+                  if (number != NULL)
+                    {
+                      gchar *endptr;
+
+                      number++;
+                      index = g_ascii_strtoll (number, &endptr, 10);
+                      if (index == 0 && endptr == (number))
+                        index = -1;
+                    }
+                }
+            }
+
+          suffix = g_strdup_printf (":%d", index);
+
+          g_variant_get (devices_variant,
+                         "a{ss}",
+                         &iter);
+
+          while (g_variant_iter_next (iter, "{&s&s}", &key, &value))
+            {
+              if (g_str_has_suffix (key, suffix))
+                {
+                  if (g_str_has_prefix (key, "device-id"))
+                    {
+                      device_id = g_strdup (value);
+                    }
+
+                  if (g_str_has_prefix (key, "device-make-and-model"))
+                    {
+                      device_make_and_model = g_strdup (value);
+                    }
+                }
+            }
+        }
+    }
+  else
+    {
+      if (!g_error_matches (error, G_IO_ERROR, G_IO_ERROR_CANCELLED))
+        g_warning ("%s", error->message);
+    }
+
+  if (!device_id || !device_make_and_model)
+    {
+      GVariantBuilder *include_scheme_builder = NULL;
+      GVariantBuilder *exclude_scheme_builder = NULL;
+
+      g_free (device_id);
+      g_free (device_make_and_model);
+
+      device_id = NULL;
+      device_make_and_model = NULL;
+
+      if (data->backend_list && !g_cancellable_is_cancelled (data->cancellable))
+        {
+          const gchar *backend_name;
+
+          backend_name = data->backend_list->data;
+
+          if (g_strcmp0 (backend_name, OTHER_BACKENDS) != 0)
+            {
+              include_scheme_builder = g_variant_builder_new (G_VARIANT_TYPE ("as"));
+              g_variant_builder_add (include_scheme_builder, "s", backend_name);
+            }
+          else
+            {
+              exclude_scheme_builder = create_other_backends_array ();
+            }
+
+          data->backend_list = g_list_delete_link (data->backend_list, data->backend_list);
+
+          g_dbus_connection_call (G_DBUS_CONNECTION (g_object_ref (source_object)),
+                                  MECHANISM_BUS,
+                                  "/",
+                                  MECHANISM_BUS,
+                                  "DevicesGet",
+                                  g_variant_new ("(iiasas)",
+                                                 0,
+                                                 0,
+                                                 include_scheme_builder,
+                                                 exclude_scheme_builder),
+                                  G_VARIANT_TYPE ("(sa{ss})"),
+                                  G_DBUS_CALL_FLAGS_NONE,
+                                  DBUS_TIMEOUT,
+                                  data->cancellable,
+                                  get_device_attributes_async_dbus_cb,
+                                  data);
+          g_steal_pointer (&data);
+
+          if (include_scheme_builder)
+            g_variant_builder_unref (include_scheme_builder);
+
+          if (exclude_scheme_builder)
+            g_variant_builder_unref (exclude_scheme_builder);
+
+          return;
+        }
+    }
+
+  data->callback (device_id,
+                  device_make_and_model,
+                  data->device_uri,
+                  data->user_data);
+}
+
+static void
+get_device_attributes_async_scb (GHashTable *result,
+                                 gpointer    user_data)
+{
+  g_autoptr(GDBusConnection) bus = NULL;
+  GVariantBuilder   include_scheme_builder;
+  IPPAttribute     *attr;
+  g_autoptr(GDAData) data = user_data;
+  g_autoptr(GError) error = NULL;
+
+  if (result)
+    {
+      attr = g_hash_table_lookup (result, "device-uri");
+      if (attr && attr->attribute_type == IPP_ATTRIBUTE_TYPE_STRING &&
+          attr->num_of_values > 0)
+      data->device_uri = g_strdup (attr->attribute_values[0].string_value);
+      g_hash_table_unref (result);
+    }
+
+  if (g_cancellable_is_cancelled (data->cancellable))
+    {
+      data->callback (NULL, NULL, NULL, data->user_data);
+      return;
+    }
+
+  if (!data->device_uri)
+    {
+      data->callback (NULL, NULL, NULL, data->user_data);
+      return;
+    }
+
+  bus = g_bus_get_sync (G_BUS_TYPE_SYSTEM, NULL, &error);
+  if (!bus)
+    {
+      g_warning ("Failed to get system bus: %s", error->message);
+      data->callback (NULL, NULL, NULL, data->user_data);
+      return;
+    }
+
+  data->backend_list = create_backends_list ();
+
+  g_variant_builder_init (&include_scheme_builder, G_VARIANT_TYPE ("as"));
+  g_variant_builder_add (&include_scheme_builder, "s", data->backend_list->data);
+
+  data->backend_list = g_list_delete_link (data->backend_list, data->backend_list);
+
+  g_dbus_connection_call (g_object_ref (bus),
+                          MECHANISM_BUS,
+                          "/",
+                          MECHANISM_BUS,
+                          "DevicesGet",
+                          g_variant_new ("(iiasas)",
+                                         0,
+                                         0,
+                                         &include_scheme_builder,
+                                         NULL),
+                          G_VARIANT_TYPE ("(sa{ss})"),
+                          G_DBUS_CALL_FLAGS_NONE,
+                          DBUS_TIMEOUT,
+                          data->cancellable,
+                          get_device_attributes_async_dbus_cb,
+                          data);
+   g_steal_pointer (&data);
+}
+
+/*
+ * Get device-id, device-make-and-model and device-uri for given printer.
+ */
+static void
+get_device_attributes_async (const gchar  *printer_name,
+                             GCancellable *cancellable,
+                             GDACallback   callback,
+                             gpointer      user_data)
+{
+  g_auto(GStrv) attributes = NULL;
+
+  if (!printer_name)
+   {
+     callback (NULL, NULL, NULL, user_data);
+     return;
+   }
+
+  attributes = g_new0 (gchar *, 2);
+  attributes[0] = g_strdup ("device-uri");
+
+  get_ipp_attributes_async (printer_name,
+                            attributes,
+                            get_device_attributes_async_scb,
+                            gda_data_new (printer_name, cancellable, callback, user_data));
+}
+
+/*
+ * Return "count" best matching driver names for given printer.
+ */
+void
+get_ppd_names_async (gchar        *printer_name,
+                     gint          count,
+                     GCancellable *cancellable,
+                     GPNCallback   callback,
+                     gpointer      user_data)
+{
+  if (!printer_name)
+    {
+      callback (NULL, NULL, TRUE, user_data);
+      return;
+    }
+
+  /*
+   * We have to find out device-id for this printer at first.
+   */
+  get_device_attributes_async (printer_name,
+                               cancellable,
+                               get_device_attributes_cb,
+                               gpn_data_new (printer_name, count, cancellable, callback, user_data));
+}
+
+typedef struct
+{
+  PPDList      *result;
+  GCancellable *cancellable;
+  GAPCallback   callback;
+  gpointer      user_data;
+  GMainContext *context;
+} GAPData;
+
+static GAPData *
+gap_data_new (GCancellable *cancellable, GAPCallback callback, gpointer user_data)
+{
+  GAPData *data;
+
+  data = g_new0 (GAPData, 1);
+  if (cancellable)
+    data->cancellable = g_object_ref (cancellable);
+  data->callback = callback;
+  data->user_data = user_data;
+  data->context = g_main_context_ref_thread_default ();
+
+  return data;
+}
+
+static void
+gap_data_free (GAPData *data)
+{
+  if (data->result != NULL)
+    ppd_list_free (data->result);
+  g_clear_object (&data->cancellable);
+  if (data->context)
+    g_main_context_unref (data->context);
+  g_free (data);
+}
+
+static gboolean
+get_all_ppds_idle_cb (gpointer user_data)
+{
+  GAPData *data = user_data;
+
+  if (!g_cancellable_is_cancelled (data->cancellable))
+    data->callback (data->result, data->user_data);
+
+  return FALSE;
+}
+
+static void
+get_all_ppds_cb (gpointer user_data)
+{
+  GAPData *data = user_data;
+  g_autoptr(GSource) idle_source = NULL;
+
+  idle_source = g_idle_source_new ();
+  g_source_set_callback (idle_source,
+                         get_all_ppds_idle_cb,
+                         data,
+                         (GDestroyNotify) gap_data_free);
+  g_source_attach (idle_source, data->context);
+}
+
+static const struct {
+  const char *normalized_name;
+  const char *display_name;
+} manufacturers_names[] = {
+  { "alps", "Alps" },
+  { "anitech", "Anitech" },
+  { "apple", "Apple" },
+  { "apollo", "Apollo" },
+  { "brother", "Brother" },
+  { "canon", "Canon" },
+  { "citizen", "Citizen" },
+  { "citoh", "Citoh" },
+  { "compaq", "Compaq" },
+  { "dec", "DEC" },
+  { "dell", "Dell" },
+  { "dnp", "DNP" },
+  { "dymo", "Dymo" },
+  { "epson", "Epson" },
+  { "fujifilm", "Fujifilm" },
+  { "fujitsu", "Fujitsu" },
+  { "gelsprinter", "Ricoh" },
+  { "generic", "Generic" },
+  { "genicom", "Genicom" },
+  { "gestetner", "Gestetner" },
+  { "hewlett packard", "Hewlett-Packard" },
+  { "heidelberg", "Heidelberg" },
+  { "hitachi", "Hitachi" },
+  { "hp", "Hewlett-Packard" },
+  { "ibm", "IBM" },
+  { "imagen", "Imagen" },
+  { "imagistics", "Imagistics" },
+  { "infoprint", "InfoPrint" },
+  { "infotec", "Infotec" },
+  { "intellitech", "Intellitech" },
+  { "kodak", "Kodak" },
+  { "konica minolta", "Minolta" },
+  { "kyocera", "Kyocera" },
+  { "kyocera mita", "Kyocera" },
+  { "lanier", "Lanier" },
+  { "lexmark international", "Lexmark" },
+  { "lexmark", "Lexmark" },
+  { "minolta", "Minolta" },
+  { "minolta qms", "Minolta" },
+  { "mitsubishi", "Mitsubishi" },
+  { "nec", "NEC" },
+  { "nrg", "NRG" },
+  { "oce", "Oce" },
+  { "oki", "Oki" },
+  { "oki data corp", "Oki" },
+  { "olivetti", "Olivetti" },
+  { "olympus", "Olympus" },
+  { "panasonic", "Panasonic" },
+  { "pcpi", "PCPI" },
+  { "pentax", "Pentax" },
+  { "qms", "QMS" },
+  { "raven", "Raven" },
+  { "raw", "Raw" },
+  { "ricoh", "Ricoh" },
+  { "samsung", "Samsung" },
+  { "savin", "Savin" },
+  { "seiko", "Seiko" },
+  { "sharp", "Sharp" },
+  { "shinko", "Shinko" },
+  { "sipix", "SiPix" },
+  { "sony", "Sony" },
+  { "star", "Star" },
+  { "tally", "Tally" },
+  { "tektronix", "Tektronix" },
+  { "texas instruments", "Texas Instruments" },
+  { "toshiba", "Toshiba" },
+  { "toshiba tec corp.", "Toshiba" },
+  { "xante", "Xante" },
+  { "xerox", "Xerox" },
+  { "zebra", "Zebra" },
+};
+
+static gpointer
+get_all_ppds_func (gpointer user_data)
+{
+  ipp_attribute_t *attr;
+  GHashTable      *ppds_hash = NULL;
+  GHashTable      *manufacturers_hash = NULL;
+  GAPData         *data = user_data;
+  PPDName         *item;
+  ipp_t           *request;
+  ipp_t           *response;
+  GList           *list;
+  gchar           *manufacturer_display_name;
+  gint             i, j;
+
+  request = ippNewRequest (CUPS_GET_PPDS);
+  response = cupsDoRequest (CUPS_HTTP_DEFAULT, request, "/");
+
+  if (response &&
+      ippGetStatusCode (response) <= IPP_OK_CONFLICT)
+    {
+      /*
+       * This hash contains names of manufacturers as keys and
+       * values are GLists of PPD names.
+       */
+      ppds_hash = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, NULL);
+
+      /*
+       * This hash contains all possible names of manufacturers as keys
+       * and values are just first occurrences of their equivalents.
+       * This is for mapping of e.g. "Hewlett Packard" and "HP" to the same name
+       * (the one which comes first).
+       */
+      manufacturers_hash = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, g_free);
+
+      for (i = 0; i < G_N_ELEMENTS (manufacturers_names); i++)
+        {
+          g_hash_table_insert (manufacturers_hash,
+                               g_strdup (manufacturers_names[i].normalized_name),
+                               g_strdup (manufacturers_names[i].display_name));
+        }
+
+      for (attr = ippFirstAttribute (response); attr != NULL; attr = ippNextAttribute (response))
+        {
+          const gchar      *ppd_device_id = NULL;
+          const gchar      *ppd_make_and_model = NULL;
+          const gchar      *ppd_name = NULL;
+          const gchar      *ppd_product = NULL;
+          const gchar      *ppd_make = NULL;
+          g_autofree gchar *mdl = NULL;
+          g_autofree gchar *mfg = NULL;
+          g_autofree gchar *mfg_normalized = NULL;
+
+          while (attr != NULL && ippGetGroupTag (attr) != IPP_TAG_PRINTER)
+            attr = ippNextAttribute (response);
+
+          if (attr == NULL)
+            break;
+
+          while (attr != NULL && ippGetGroupTag (attr) == IPP_TAG_PRINTER)
+            {
+              if (g_strcmp0 (ippGetName (attr), "ppd-device-id") == 0 &&
+                  ippGetValueTag (attr) == IPP_TAG_TEXT)
+                ppd_device_id = ippGetString (attr, 0, NULL);
+              else if (g_strcmp0 (ippGetName (attr), "ppd-make-and-model") == 0 &&
+                       ippGetValueTag (attr) == IPP_TAG_TEXT)
+                ppd_make_and_model = ippGetString (attr, 0, NULL);
+              else if (g_strcmp0 (ippGetName (attr), "ppd-name") == 0 &&
+                       ippGetValueTag (attr) == IPP_TAG_NAME)
+                ppd_name = ippGetString (attr, 0, NULL);
+              else if (g_strcmp0 (ippGetName (attr), "ppd-product") == 0 &&
+                       ippGetValueTag (attr) == IPP_TAG_TEXT)
+                ppd_product = ippGetString (attr, 0, NULL);
+              else if (g_strcmp0 (ippGetName (attr), "ppd-make") == 0 &&
+                       ippGetValueTag (attr) == IPP_TAG_TEXT)
+                ppd_make = ippGetString (attr, 0, NULL);
+
+              attr = ippNextAttribute (response);
+            }
+
+          /* Get manufacturer's name */
+          if (ppd_device_id && ppd_device_id[0] != '\0')
+            {
+              mfg = get_tag_value (ppd_device_id, "mfg");
+              if (!mfg)
+                mfg = get_tag_value (ppd_device_id, "manufacturer");
+              mfg_normalized = normalize (mfg);
+            }
+
+          if (!mfg &&
+              ppd_make &&
+              ppd_make[0] != '\0')
+            {
+              mfg = g_strdup (ppd_make);
+              mfg_normalized = normalize (ppd_make);
+            }
+
+          /* Get model */
+          if (ppd_make_and_model &&
+              ppd_make_and_model[0] != '\0')
+            {
+              mdl = g_strdup (ppd_make_and_model);
+            }
+
+          if (!mdl &&
+              ppd_product &&
+              ppd_product[0] != '\0')
+            {
+              mdl = g_strdup (ppd_product);
+            }
+
+          if (!mdl &&
+              ppd_device_id &&
+              ppd_device_id[0] != '\0')
+            {
+              mdl = get_tag_value (ppd_device_id, "mdl");
+              if (!mdl)
+                mdl = get_tag_value (ppd_device_id, "model");
+            }
+
+          if (ppd_name && ppd_name[0] != '\0' &&
+              mdl && mdl[0] != '\0' &&
+              mfg && mfg[0] != '\0')
+            {
+              manufacturer_display_name = g_hash_table_lookup (manufacturers_hash, mfg_normalized);
+              if (!manufacturer_display_name)
+                {
+                  g_hash_table_insert (manufacturers_hash, g_strdup (mfg_normalized), g_strdup (mfg));
+                }
+              else
+                {
+                  g_free (mfg_normalized);
+                  mfg_normalized = normalize (manufacturer_display_name);
+                }
+
+              item = g_new0 (PPDName, 1);
+              item->ppd_name = g_strdup (ppd_name);
+              item->ppd_display_name = g_strdup (mdl);
+              item->ppd_match_level = -1;
+
+              list = g_hash_table_lookup (ppds_hash, mfg_normalized);
+              if (list)
+                {
+                  list = g_list_append (list, item);
+                }
+              else
+                {
+                  list = g_list_append (list, item);
+                  g_hash_table_insert (ppds_hash, g_strdup (mfg_normalized), list);
+                }
+            }
+
+          if (attr == NULL)
+            break;
+        }
+    }
+
+  if (response)
+    ippDelete(response);
+
+  if (ppds_hash &&
+      manufacturers_hash)
+    {
+      GHashTableIter  iter;
+      gpointer        key;
+      gpointer        value;
+      GList          *ppd_item;
+      GList          *sort_list = NULL;
+      GList          *list_iter;
+      gchar          *name;
+
+      data->result = g_new0 (PPDList, 1);
+      data->result->num_of_manufacturers = g_hash_table_size (ppds_hash);
+      data->result->manufacturers = g_new0 (PPDManufacturerItem *, data->result->num_of_manufacturers);
+
+      g_hash_table_iter_init (&iter, ppds_hash);
+      while (g_hash_table_iter_next (&iter, &key, &value))
+        {
+          sort_list = g_list_append (sort_list, g_strdup (key));
+        }
+
+      /* Sort list of manufacturers */
+      sort_list = g_list_sort (sort_list, (GCompareFunc) g_strcmp0);
+
+      /*
+       * Fill resulting list of lists (list of manufacturers where
+       * each item contains list of PPD names)
+       */
+      i = 0;
+      for (list_iter = sort_list; list_iter; list_iter = list_iter->next)
+        {
+          name = (gchar *) list_iter->data;
+          value = g_hash_table_lookup (ppds_hash, name);
+
+          data->result->manufacturers[i] = g_new0 (PPDManufacturerItem, 1);
+          data->result->manufacturers[i]->manufacturer_name = g_strdup (name);
+          data->result->manufacturers[i]->manufacturer_display_name = g_strdup (g_hash_table_lookup (manufacturers_hash, name));
+          data->result->manufacturers[i]->num_of_ppds = g_list_length ((GList *) value);
+          data->result->manufacturers[i]->ppds = g_new0 (PPDName *, data->result->manufacturers[i]->num_of_ppds);
+
+          for (ppd_item = (GList *) value, j = 0; ppd_item; ppd_item = ppd_item->next, j++)
+            {
+              data->result->manufacturers[i]->ppds[j] = ppd_item->data;
+            }
+
+          g_list_free ((GList *) value);
+
+          i++;
+        }
+
+      g_list_free_full (sort_list, g_free);
+      g_hash_table_destroy (ppds_hash);
+      g_hash_table_destroy (manufacturers_hash);
+    }
+
+  get_all_ppds_cb (data);
+
+  return NULL;
+}
+
+/*
+ * Get names of all installed PPDs sorted by manufacturers names.
+ */
+void
+get_all_ppds_async (GCancellable *cancellable,
+                    GAPCallback   callback,
+                    gpointer      user_data)
+{
+  GAPData          *data;
+  g_autoptr(GThread) thread = NULL;
+  g_autoptr(GError)  error = NULL;
+
+  data = gap_data_new (cancellable, callback, user_data);
+
+  thread = g_thread_try_new ("get-all-ppds",
+                             get_all_ppds_func,
+                             data,
+                             &error);
+
+  if (!thread)
+    {
+      g_warning ("%s", error->message);
+      callback (NULL, user_data);
+
+      gap_data_free (data);
+    }
+}
+
+PPDList *
+ppd_list_copy (PPDList *list)
+{
+  PPDList *result = NULL;
+  gint     i, j;
+
+  if (list)
+    {
+      result = g_new0 (PPDList, 1);
+      result->num_of_manufacturers = list->num_of_manufacturers;
+      result->manufacturers = g_new0 (PPDManufacturerItem *, list->num_of_manufacturers);
+
+      for (i = 0; i < result->num_of_manufacturers; i++)
+        {
+          result->manufacturers[i] = g_new0 (PPDManufacturerItem, 1);
+          result->manufacturers[i]->num_of_ppds = list->manufacturers[i]->num_of_ppds;
+          result->manufacturers[i]->ppds = g_new0 (PPDName *, result->manufacturers[i]->num_of_ppds);
+
+          result->manufacturers[i]->manufacturer_display_name =
+            g_strdup (list->manufacturers[i]->manufacturer_display_name);
+
+          result->manufacturers[i]->manufacturer_name =
+            g_strdup (list->manufacturers[i]->manufacturer_name);
+
+          for (j = 0; j < result->manufacturers[i]->num_of_ppds; j++)
+            {
+              result->manufacturers[i]->ppds[j] = g_new0 (PPDName, 1);
+
+              result->manufacturers[i]->ppds[j]->ppd_display_name =
+                g_strdup (list->manufacturers[i]->ppds[j]->ppd_display_name);
+
+              result->manufacturers[i]->ppds[j]->ppd_name =
+                g_strdup (list->manufacturers[i]->ppds[j]->ppd_name);
+
+              result->manufacturers[i]->ppds[j]->ppd_match_level =
+                list->manufacturers[i]->ppds[j]->ppd_match_level;
+            }
+        }
+    }
+
+  return result;
+}
+
+void
+ppd_list_free (PPDList *list)
+{
+  gint i, j;
+
+  if (list)
+    {
+      for (i = 0; i < list->num_of_manufacturers; i++)
+        {
+          for (j = 0; j < list->manufacturers[i]->num_of_ppds; j++)
+            {
+              g_free (list->manufacturers[i]->ppds[j]->ppd_name);
+              g_free (list->manufacturers[i]->ppds[j]->ppd_display_name);
+              g_free (list->manufacturers[i]->ppds[j]);
+            }
+
+          g_free (list->manufacturers[i]->manufacturer_name);
+          g_free (list->manufacturers[i]->manufacturer_display_name);
+          g_free (list->manufacturers[i]->ppds);
+          g_free (list->manufacturers[i]);
+        }
+
+      g_free (list->manufacturers);
+      g_free (list);
+    }
+}
+
+gchar *
+get_standard_manufacturers_name (const gchar *name)
+{
+  g_autofree gchar *normalized_name = NULL;
+  gint   i;
+
+  if (name == NULL)
+    return NULL;
+
+  normalized_name = normalize (name);
+
+  for (i = 0; i < G_N_ELEMENTS (manufacturers_names); i++)
+    {
+      if (g_strcmp0 (manufacturers_names[i].normalized_name, normalized_name) == 0)
+        {
+          return g_strdup (manufacturers_names[i].display_name);
+        }
+    }
+
+  return NULL;
+}
+
+typedef struct
+{
+  gchar        *printer_name;
+  gchar        *host_name;
+  gint          port;
+  gchar        *result;
+  PGPCallback   callback;
+  gpointer      user_data;
+  GMainContext *context;
+} PGPData;
+
+static PGPData *
+pgp_data_new (const gchar *printer_name, const gchar *host_name, gint port, PGPCallback callback, gpointer user_data)
+{
+  PGPData *data;
+
+  data = g_new0 (PGPData, 1);
+  data->printer_name = g_strdup (printer_name);
+  data->host_name = g_strdup (host_name);
+  data->port = port;
+  data->callback = callback;
+  data->user_data = user_data;
+  data->context = g_main_context_ref_thread_default ();
+
+  return data;
+}
+
+static void
+pgp_data_free (PGPData *data)
+{
+  g_free (data->printer_name);
+  g_free (data->host_name);
+  g_free (data->result);
+  if (data->context)
+    g_main_context_unref (data->context);
+  g_free (data);
+}
+
+static gboolean
+printer_get_ppd_idle_cb (gpointer user_data)
+{
+  PGPData *data = user_data;
+
+  data->callback (data->result, data->user_data);
+
+  return FALSE;
+}
+
+static void
+printer_get_ppd_cb (gpointer user_data)
+{
+  PGPData *data = user_data;
+  g_autoptr(GSource) idle_source = NULL;
+
+  idle_source = g_idle_source_new ();
+  g_source_set_callback (idle_source,
+                         printer_get_ppd_idle_cb,
+                         data,
+                         (GDestroyNotify) pgp_data_free);
+  g_source_attach (idle_source, data->context);
+}
+
+static gpointer
+printer_get_ppd_func (gpointer user_data)
+{
+  PGPData *data = user_data;
+
+  if (data->host_name)
+    {
+      http_t *http;
+
+#ifdef HAVE_CUPS_HTTPCONNECT2
+      http = httpConnect2 (data->host_name, data->port, NULL, AF_UNSPEC,
+                           HTTP_ENCRYPTION_IF_REQUESTED, 1, 30000, NULL);
+#else
+      http = httpConnect (data->host_name, data->port);
+#endif
+      if (http)
+        {
+          data->result = g_strdup (cupsGetPPD2 (http, data->printer_name));
+          httpClose (http);
+        }
+    }
+  else
+    {
+      data->result = g_strdup (cupsGetPPD (data->printer_name));
+    }
+
+  printer_get_ppd_cb (data);
+
+  return NULL;
+}
+
+void
+printer_get_ppd_async (const gchar *printer_name,
+                       const gchar *host_name,
+                       gint         port,
+                       PGPCallback  callback,
+                       gpointer     user_data)
+{
+  PGPData          *data;
+  g_autoptr(GThread) thread = NULL;
+  g_autoptr(GError) error = NULL;
+
+  data = pgp_data_new (printer_name, host_name, port, callback, user_data);
+
+  thread = g_thread_try_new ("printer-get-ppd",
+                             printer_get_ppd_func,
+                             data,
+                             &error);
+
+  if (!thread)
+    {
+      g_warning ("%s", error->message);
+      callback (NULL, user_data);
+
+      pgp_data_free (data);
+    }
+}
+
+typedef struct
+{
+  gchar        *printer_name;
+  cups_dest_t  *result;
+  GNDCallback   callback;
+  gpointer      user_data;
+  GMainContext *context;
+} GNDData;
+
+static GNDData *
+gnd_data_new (const gchar *printer_name, GNDCallback callback, gpointer user_data)
+{
+  GNDData *data;
+
+  data = g_new0 (GNDData, 1);
+  data->printer_name = g_strdup (printer_name);
+  data->callback = callback;
+  data->user_data = user_data;
+  data->context = g_main_context_ref_thread_default ();
+
+  return data;
+}
+
+static void
+gnd_data_free (GNDData *data)
+{
+  g_free (data->printer_name);
+  if (data->context)
+    g_main_context_unref (data->context);
+  g_free (data);
+}
+
+static gboolean
+get_named_dest_idle_cb (gpointer user_data)
+{
+  GNDData *data = user_data;
+
+  data->callback (data->result, data->user_data);
+
+  return FALSE;
+}
+
+static void
+get_named_dest_cb (gpointer user_data)
+{
+  GNDData *data = user_data;
+  g_autoptr(GSource) idle_source = NULL;
+
+  idle_source = g_idle_source_new ();
+  g_source_set_callback (idle_source,
+                         get_named_dest_idle_cb,
+                         data,
+                         (GDestroyNotify) gnd_data_free);
+  g_source_attach (idle_source, data->context);
+}
+
+static gpointer
+get_named_dest_func (gpointer user_data)
+{
+  GNDData *data = user_data;
+
+  data->result = cupsGetNamedDest (CUPS_HTTP_DEFAULT, data->printer_name, NULL);
+
+  get_named_dest_cb (data);
+
+  return NULL;
+}
+
+void
+get_named_dest_async (const gchar *printer_name,
+                      GNDCallback  callback,
+                      gpointer     user_data)
+{
+  GNDData          *data;
+  g_autoptr(GThread) thread = NULL;
+  g_autoptr(GError) error = NULL;
+
+  data = gnd_data_new (printer_name, callback, user_data);
+
+  thread = g_thread_try_new ("get-named-dest",
+                             get_named_dest_func,
+                             data,
+                             &error);
+
+  if (!thread)
+    {
+      g_warning ("%s", error->message);
+      callback (NULL, user_data);
+
+      gnd_data_free (data);
+    }
+}
+
+typedef struct
+{
+  GCancellable *cancellable;
+  PAOCallback   callback;
+  gpointer      user_data;
+} PAOData;
+
+static PAOData *
+pao_data_new (GCancellable *cancellable, PAOCallback callback, gpointer user_data)
+{
+  PAOData *data;
+
+  data = g_new0 (PAOData, 1);
+  if (cancellable)
+    data->cancellable = g_object_ref (cancellable);
+  data->callback = callback;
+  data->user_data = user_data;
+  return data;
+}
+
+static void
+pao_data_free (PAOData *data)
+{
+  g_clear_object (&data->cancellable);
+  g_free (data);
+}
+
+G_DEFINE_AUTOPTR_CLEANUP_FUNC (PAOData, pao_data_free)
+
+static void
+printer_add_option_async_dbus_cb (GObject      *source_object,
+                                  GAsyncResult *res,
+                                  gpointer      user_data)
+{
+  g_autoptr(GVariant) output = NULL;
+  gboolean            success = FALSE;
+  g_autoptr(PAOData)  data = user_data;
+  g_autoptr(GError)   error = NULL;
+
+  output = g_dbus_connection_call_finish (G_DBUS_CONNECTION (source_object),
+                                          res,
+                                          &error);
+
+  if (output)
+    {
+      const gchar *ret_error;
+
+      g_variant_get (output, "(&s)", &ret_error);
+      if (ret_error[0] != '\0')
+        g_warning ("cups-pk-helper: setting of an option failed: %s", ret_error);
+      else
+        success = TRUE;
+    }
+  else
+    {
+      if (!g_error_matches (error, G_IO_ERROR, G_IO_ERROR_CANCELLED))
+        g_warning ("%s", error->message);
+    }
+
+  if (!g_cancellable_is_cancelled (data->cancellable))
+    data->callback (success, data->user_data);
+}
+
+void
+printer_add_option_async (const gchar   *printer_name,
+                          const gchar   *option_name,
+                          gchar        **values,
+                          gboolean       set_default,
+                          GCancellable  *cancellable,
+                          PAOCallback    callback,
+                          gpointer       user_data)
+{
+  GVariantBuilder   array_builder;
+  g_autoptr(GDBusConnection) bus = NULL;
+  g_autoptr(GError) error = NULL;
+  gint              i;
+
+  bus = g_bus_get_sync (G_BUS_TYPE_SYSTEM, NULL, &error);
+  if (!bus)
+   {
+     g_warning ("Failed to get system bus: %s", error->message);
+     callback (FALSE, user_data);
+     return;
+   }
+
+  g_variant_builder_init (&array_builder, G_VARIANT_TYPE ("as"));
+  if (values)
+    {
+      for (i = 0; values[i]; i++)
+        g_variant_builder_add (&array_builder, "s", values[i]);
+    }
+
+  g_dbus_connection_call (bus,
+                          MECHANISM_BUS,
+                          "/",
+                          MECHANISM_BUS,
+                          set_default ? "PrinterAddOptionDefault" :
+                                        "PrinterAddOption",
+                          g_variant_new ("(ssas)",
+                                         printer_name,
+                                         option_name,
+                                         &array_builder),
+                          G_VARIANT_TYPE ("(s)"),
+                          G_DBUS_CALL_FLAGS_NONE,
+                          DBUS_TIMEOUT,
+                          cancellable,
+                          printer_add_option_async_dbus_cb,
+                          pao_data_new (cancellable, callback, user_data));
+}
+
+typedef struct
+{
+  GList        *backend_list;
+  GCancellable *cancellable;
+  GCDCallback   callback;
+  gpointer      user_data;
+} GCDData;
+
+static GCDData *
+gcd_data_new (GList *backend_list, GCancellable *cancellable, GCDCallback callback, gpointer user_data)
+{
+  GCDData *data;
+
+  data = g_new0 (GCDData, 1);
+  data->backend_list = backend_list;
+  if (cancellable)
+    data->cancellable = g_object_ref (cancellable);
+  data->callback = callback;
+  data->user_data = user_data;
+
+  return data;
+}
+
+static void
+gcd_data_free (GCDData *data)
+{
+  g_list_free_full (data->backend_list, g_free);
+  g_clear_object (&data->cancellable);
+  g_free (data);
+}
+
+G_DEFINE_AUTOPTR_CLEANUP_FUNC (GCDData, gcd_data_free)
+
+static gint
+get_suffix_index (const gchar *string)
+{
+  gchar *number;
+  gchar *endptr;
+  gint   index = -1;
+
+  number = g_strrstr (string, ":");
+  if (number)
+    {
+      number++;
+      index = g_ascii_strtoll (number, &endptr, 10);
+      if (index == 0 && endptr == number)
+        index = -1;
+    }
+
+  return index;
+}
+
+static void
+get_cups_devices_async_dbus_cb (GObject      *source_object,
+                                GAsyncResult *res,
+                                gpointer      user_data)
+
+{
+  g_autoptr(GPtrArray) devices = NULL;
+  g_autoptr(GVariant) output = NULL;
+  g_autoptr(GCDData)  data = user_data;
+  g_autoptr(GError)   error = NULL;
+  gint                num_of_devices = 0;
+
+  output = g_dbus_connection_call_finish (G_DBUS_CONNECTION (source_object),
+                                          res,
+                                          &error);
+
+  if (output)
+    {
+      const gchar *ret_error;
+      g_autoptr(GVariant) devices_variant = NULL;
+      gboolean     is_network_device;
+      g_autoptr(GVariantIter) iter = NULL;
+      const gchar  *key, *value;
+      gint          index = -1, max_index = -1, i;
+
+      g_variant_get (output, "(&s@a{ss})",
+                     &ret_error,
+                     &devices_variant);
+
+      if (ret_error[0] != '\0')
+        {
+          g_warning ("cups-pk-helper: getting of CUPS devices failed: %s", ret_error);
+        }
+
+      g_variant_get (devices_variant, "a{ss}", &iter);
+      while (g_variant_iter_next (iter, "{&s&s}", &key, &value))
+        {
+          index = get_suffix_index (key);
+          if (index > max_index)
+            max_index = index;
+        }
+
+      if (max_index >= 0)
+        {
+          g_autoptr(GVariantIter) iter2 = NULL;
+
+          num_of_devices = max_index + 1;
+          devices = g_ptr_array_new_with_free_func (g_object_unref);
+          for (i = 0; i < num_of_devices; i++)
+             g_ptr_array_add (devices, pp_print_device_new ());
+
+          g_variant_get (devices_variant, "a{ss}", &iter2);
+          while (g_variant_iter_next (iter2, "{&s&s}", &key, &value))
+            {
+              PpPrintDevice *device;
+
+              index = get_suffix_index (key);
+              if (index >= 0)
+                {
+                  device = g_ptr_array_index (devices, index);
+                  if (g_str_has_prefix (key, "device-class"))
+                    {
+                      is_network_device = g_strcmp0 (value, "network") == 0;
+                      g_object_set (device, "is-network-device", is_network_device, NULL);
+                    }
+                  else if (g_str_has_prefix (key, "device-id"))
+                    g_object_set (device, "device-id", value, NULL);
+                  else if (g_str_has_prefix (key, "device-info"))
+                    g_object_set (device, "device-info", value, NULL);
+                  else if (g_str_has_prefix (key, "device-make-and-model"))
+                    {
+                      g_object_set (device,
+                                    "device-make-and-model", value,
+                                    "device-name", value,
+                                    NULL);
+                    }
+                  else if (g_str_has_prefix (key, "device-uri"))
+                    g_object_set (device, "device-uri", value, NULL);
+                  else if (g_str_has_prefix (key, "device-location"))
+                    g_object_set (device, "device-location", value, NULL);
+
+                  g_object_set (device, "acquisition-method", ACQUISITION_METHOD_DEFAULT_CUPS_SERVER, NULL);
+                }
+            }
+        }
+    }
+  else
+    {
+      if (!g_error_matches (error, G_IO_ERROR, G_IO_ERROR_CANCELLED))
+        g_warning ("%s", error->message);
+
+      data->callback (devices,
+                      TRUE,
+                      g_cancellable_is_cancelled (data->cancellable),
+                      data->user_data);
+      return;
+    }
+
+  if (data->backend_list)
+    {
+      if (!g_cancellable_is_cancelled (data->cancellable))
+        {
+          GVariantBuilder  *include_scheme_builder = NULL;
+          GVariantBuilder  *exclude_scheme_builder = NULL;
+          g_autofree gchar *backend_name = NULL;
+
+          backend_name = data->backend_list->data;
+
+          data->callback (devices,
+                          FALSE,
+                          FALSE,
+                          data->user_data);
+
+          if (g_strcmp0 (backend_name, OTHER_BACKENDS) != 0)
+            {
+              include_scheme_builder = g_variant_builder_new (G_VARIANT_TYPE ("as"));
+              g_variant_builder_add (include_scheme_builder, "s", backend_name);
+            }
+          else
+            {
+              exclude_scheme_builder = create_other_backends_array ();
+            }
+
+          data->backend_list = g_list_delete_link (data->backend_list, data->backend_list);
+
+          g_dbus_connection_call (G_DBUS_CONNECTION (g_object_ref (source_object)),
+                                  MECHANISM_BUS,
+                                  "/",
+                                  MECHANISM_BUS,
+                                  "DevicesGet",
+                                  g_variant_new ("(iiasas)",
+                                                 0,
+                                                 0,
+                                                 include_scheme_builder,
+                                                 exclude_scheme_builder),
+                                  G_VARIANT_TYPE ("(sa{ss})"),
+                                  G_DBUS_CALL_FLAGS_NONE,
+                                  DBUS_TIMEOUT,
+                                  data->cancellable,
+                                  get_cups_devices_async_dbus_cb,
+                                  data);
+          g_steal_pointer (&data);
+
+          if (include_scheme_builder)
+            g_variant_builder_unref (include_scheme_builder);
+
+          if (exclude_scheme_builder)
+            g_variant_builder_unref (exclude_scheme_builder);
+
+          return;
+        }
+      else
+        {
+          data->callback (devices,
+                          TRUE,
+                          TRUE,
+                          data->user_data);
+        }
+    }
+  else
+    {
+      data->callback (devices,
+                      TRUE,
+                      g_cancellable_is_cancelled (data->cancellable),
+                      data->user_data);
+    }
+}
+
+void
+get_cups_devices_async (GCancellable *cancellable,
+                        GCDCallback   callback,
+                        gpointer      user_data)
+{
+  g_autoptr(GDBusConnection) bus = NULL;
+  GVariantBuilder   include_scheme_builder;
+  GList *backend_list;
+  g_autoptr(GError) error = NULL;
+  g_autofree gchar *backend_name = NULL;
+
+  bus = g_bus_get_sync (G_BUS_TYPE_SYSTEM, NULL, &error);
+  if (!bus)
+   {
+     g_warning ("Failed to get system bus: %s", error->message);
+     callback (NULL, TRUE, FALSE, user_data);
+     return;
+   }
+
+  backend_list = create_backends_list ();
+
+  backend_name = backend_list->data;
+
+  g_variant_builder_init (&include_scheme_builder, G_VARIANT_TYPE ("as"));
+  g_variant_builder_add (&include_scheme_builder, "s", backend_name);
+
+  backend_list = g_list_delete_link (backend_list, backend_list);
+
+  g_dbus_connection_call (bus,
+                          MECHANISM_BUS,
+                          "/",
+                          MECHANISM_BUS,
+                          "DevicesGet",
+                          g_variant_new ("(iiasas)",
+                                         0,
+                                         0,
+                                         &include_scheme_builder,
+                                         NULL),
+                          G_VARIANT_TYPE ("(sa{ss})"),
+                          G_DBUS_CALL_FLAGS_NONE,
+                          DBUS_TIMEOUT,
+                          cancellable,
+                          get_cups_devices_async_dbus_cb,
+                          gcd_data_new (backend_list, cancellable, callback, user_data));
+}
+
+gchar *
+guess_device_hostname (PpPrintDevice *device)
+{
+  http_uri_status_t  status;
+  char               scheme[HTTP_MAX_URI];
+  char               username[HTTP_MAX_URI];
+  char               hostname[HTTP_MAX_URI];
+  char               resource[HTTP_MAX_URI];
+  int                port;
+  gchar             *result = NULL;
+  gchar             *hostname_begin;
+  gchar             *hostname_end = NULL;
+
+  if (device != NULL && pp_print_device_get_device_uri (device) != NULL)
+    {
+      if (g_str_has_prefix (pp_print_device_get_device_uri (device), "socket") ||
+          g_str_has_prefix (pp_print_device_get_device_uri (device), "lpd") ||
+          g_str_has_prefix (pp_print_device_get_device_uri (device), "ipp") ||
+          g_str_has_prefix (pp_print_device_get_device_uri (device), "smb"))
+        {
+          status = httpSeparateURI (HTTP_URI_CODING_ALL,
+                                    pp_print_device_get_device_uri (device),
+                                    scheme, HTTP_MAX_URI,
+                                    username, HTTP_MAX_URI,
+                                    hostname, HTTP_MAX_URI,
+                                    &port,
+                                    resource, HTTP_MAX_URI);
+
+          if (status >= HTTP_URI_STATUS_OK &&
+              hostname[0] != '\0')
+            result = g_strdup (hostname);
+        }
+      else if ((g_str_has_prefix (pp_print_device_get_device_uri (device), "dnssd") ||
+                g_str_has_prefix (pp_print_device_get_device_uri (device), "mdns")) &&
+               pp_print_device_get_device_info (device) != NULL)
+        {
+          /*
+           * CUPS browses its printers as
+           * "PrinterName @ ComputerName" or "PrinterInfo @ ComputerName"
+           * through DNS-SD.
+           */
+          hostname_begin = g_strrstr (pp_print_device_get_device_info (device), " @ ");
+          if (hostname_begin != NULL)
+            result = g_strdup (hostname_begin + 3);
+        }
+      else if (g_str_has_prefix (pp_print_device_get_device_uri (device), "hp:/net/") ||
+               g_str_has_prefix (pp_print_device_get_device_uri (device), "hpfax:/net/"))
+        {
+          /*
+           * HPLIP printers have URI of form hp:/net/%s?ip=%s&port=%d
+           * or hp:/net/%s?ip=%s.
+           */
+          hostname_begin = g_strrstr (pp_print_device_get_device_uri (device), "ip=");
+          if (hostname_begin != NULL)
+            {
+              hostname_begin += 3;
+              hostname_end = strstr (hostname_begin, "&");
+            }
+
+          if (hostname_end != NULL)
+            result = g_strndup (hostname_begin, hostname_end - hostname_begin);
+          else
+            result = g_strdup (hostname_begin);
+        }
+    }
+
+  return result;
+}
+
+gchar *
+canonicalize_device_name (GList         *device_names,
+                          GPtrArray     *local_cups_devices,
+                          cups_dest_t   *dests,
+                          gint           num_of_dests,
+                          PpPrintDevice *device)
+{
+  PpPrintDevice             *item;
+  gboolean                   already_present;
+  GList                     *iter;
+  gsize                      len;
+  g_autofree gchar          *name = NULL;
+  gchar                     *occurrence;
+  gint                       name_index, j;
+  static const char * const  residues[] = {
+    "-foomatic",
+    "-hpijs",
+    "-hpcups",
+    "-cups",
+    "-gutenprint",
+    "-series",
+    "-label-printer",
+    "-dot-matrix",
+    "-ps3",
+    "-ps2",
+    "-br-script",
+    "-kpdl",
+    "-pcl3",
+    "-pcl",
+    "-zxs",
+    "-pxl"};
+
+  if (pp_print_device_get_device_id (device) != NULL)
+    {
+      name = get_tag_value (pp_print_device_get_device_id (device), "mdl");
+      if (name == NULL)
+        name = get_tag_value (pp_print_device_get_device_id (device), "model");
+    }
+
+  if (name == NULL &&
+      pp_print_device_get_device_make_and_model (device) != NULL &&
+      pp_print_device_get_device_make_and_model (device)[0] != '\0')
+    {
+      name = g_strdup (pp_print_device_get_device_make_and_model (device));
+    }
+
+  if (name == NULL &&
+      pp_print_device_get_device_original_name (device) != NULL &&
+      pp_print_device_get_device_original_name (device)[0] != '\0')
+    {
+      name = g_strdup (pp_print_device_get_device_original_name (device));
+    }
+
+  if (name == NULL &&
+      pp_print_device_get_device_info (device) != NULL &&
+      pp_print_device_get_device_info (device)[0] != '\0')
+    {
+      name = g_strdup (pp_print_device_get_device_info (device));
+    }
+
+  if (name == NULL)
+    return NULL;
+
+  g_strstrip (name);
+  g_strcanon (name, ALLOWED_CHARACTERS, '-');
+
+  /* Remove common strings found in driver names */
+  for (j = 0; j < G_N_ELEMENTS (residues); j++)
+    {
+      g_autofree gchar *lower_name = g_ascii_strdown (name, -1);
+
+      occurrence = g_strrstr (lower_name, residues[j]);
+      if (occurrence != NULL)
+        {
+          occurrence[0] = '\0';
+          name[strlen (lower_name)] = '\0';
+        }
+    }
+
+  /* Remove trailing "-" */
+  len = strlen (name);
+  while (len-- && name[len] == '-')
+    name[len] = '\0';
+
+  /* Merge "--" to "-" */
+  occurrence = g_strrstr (name, "--");
+  while (occurrence != NULL)
+    {
+      shift_string_left (occurrence);
+      occurrence = g_strrstr (name, "--");
+    }
+
+  /* Remove leading "-" */
+  if (name[0] == '-')
+    shift_string_left (name);
+
+  name_index = 2;
+  already_present = FALSE;
+  while (TRUE)
+    {
+      g_autofree gchar *new_name = NULL;
+
+      if (already_present)
+        {
+          new_name = g_strdup_printf ("%s-%d", name, name_index);
+          name_index++;
+        }
+      else
+        {
+          new_name = g_strdup (name);
+        }
+
+      already_present = FALSE;
+      for (j = 0; j < num_of_dests; j++)
+        if (g_strcmp0 (dests[j].name, new_name) == 0)
+          already_present = TRUE;
+
+      for (iter = device_names; iter; iter = iter->next)
+        {
+          gchar *device_original_name = iter->data;
+          if (g_strcmp0 (device_original_name, new_name) == 0)
+            already_present = TRUE;
+        }
+
+      for (guint i = 0; i < local_cups_devices->len; i++)
+        {
+          item = g_ptr_array_index (local_cups_devices, i);
+          if (g_strcmp0 (pp_print_device_get_device_original_name (item), new_name) == 0)
+            already_present = TRUE;
+        }
+
+      if (!already_present)
+        return g_steal_pointer (&new_name);
+    }
+}
+
+void
+shift_string_left (gchar *str)
+{
+  gchar *next;
+
+  if (str != NULL && str[0] != '\0')
+    {
+      next = g_utf8_find_next_char (str, NULL);
+      memmove (str, next, strlen (next) + 1);
+    }
+}
+
+gboolean
+printer_name_is_valid (const gchar *str)
+{
+  const gchar *invalid_chars = " \t#/";
+  return strlen(str) == strcspn(str, invalid_chars);
+}
diff --git a/panels/printers/pp-utils.h b/panels/printers/pp-utils.h
new file mode 100644
index 0000000..332cda4
--- /dev/null
+++ b/panels/printers/pp-utils.h
@@ -0,0 +1,263 @@
+/* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 8 -*-
+ *
+ * Copyright 2009-2010  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 2 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, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#pragma once
+
+#include <gtk/gtk.h>
+#include <cups/cups.h>
+
+#include "pp-print-device.h"
+
+#define ALLOWED_CHARACTERS "abcdefghijklmnopqrtsuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789-_"
+
+#define MECHANISM_BUS "org.opensuse.CupsPkHelper.Mechanism"
+
+#define SCP_BUS   "org.fedoraproject.Config.Printing"
+#define SCP_PATH  "/org/fedoraproject/Config/Printing"
+#define SCP_IFACE "org.fedoraproject.Config.Printing"
+
+G_BEGIN_DECLS
+
+typedef void (*UserResponseCallback) (GtkDialog *dialog, gint response_id, gpointer user_data);
+
+/*
+ * Match level of PPD driver.
+ */
+enum
+{
+  PPD_NO_MATCH = 0,
+  PPD_GENERIC_MATCH,
+  PPD_CLOSE_MATCH,
+  PPD_EXACT_MATCH,
+  PPD_EXACT_CMD_MATCH
+};
+
+enum
+{
+  ACQUISITION_METHOD_DEFAULT_CUPS_SERVER = 0,
+  ACQUISITION_METHOD_REMOTE_CUPS_SERVER,
+  ACQUISITION_METHOD_SNMP,
+  ACQUISITION_METHOD_SAMBA,
+  ACQUISITION_METHOD_SAMBA_HOST,
+  ACQUISITION_METHOD_JETDIRECT,
+  ACQUISITION_METHOD_LPD
+};
+
+typedef struct
+{
+  gchar *ppd_name;
+  gchar *ppd_display_name;
+  gint   ppd_match_level;
+} PPDName;
+
+typedef struct
+{
+  gchar    *manufacturer_name;
+  gchar    *manufacturer_display_name;
+  PPDName **ppds;
+  gsize     num_of_ppds;
+} PPDManufacturerItem;
+
+typedef struct
+{
+  PPDManufacturerItem **manufacturers;
+  gsize                 num_of_manufacturers;
+} PPDList;
+
+gchar      *get_tag_value (const gchar *tag_string,
+                           const gchar *tag_name);
+
+char       *get_dest_attr (const char *dest_name,
+                           const char *attr);
+
+gchar      *get_ppd_attribute (const gchar *ppd_file_name,
+                               const gchar *attribute_name);
+
+void        set_local_default_printer (const gchar *printer_name);
+
+gboolean    printer_set_location (const gchar *printer_name,
+                                  const gchar *location);
+
+gboolean    printer_set_accepting_jobs (const gchar *printer_name,
+                                        gboolean     accepting_jobs,
+                                        const gchar *reason);
+
+gboolean    printer_set_enabled (const gchar *printer_name,
+                                 gboolean     enabled);
+
+gboolean    printer_rename (const gchar *old_name,
+                            const gchar *new_name);
+
+gboolean    printer_delete (const gchar *printer_name);
+
+gboolean    printer_set_default (const gchar *printer_name);
+
+gboolean    printer_set_shared (const gchar *printer_name,
+                                gboolean     shared);
+
+gboolean    printer_set_job_sheets (const gchar *printer_name,
+                                    const gchar *start_sheet,
+                                    const gchar *end_sheet);
+
+gboolean    printer_set_policy (const gchar *printer_name,
+                                const gchar *policy,
+                                gboolean     error_policy);
+
+gboolean    printer_set_users (const gchar  *printer_name,
+                               gchar       **users,
+                               gboolean      allowed);
+
+gboolean    class_add_printer (const gchar *class_name,
+                               const gchar *printer_name);
+
+gboolean    printer_is_local (cups_ptype_t  printer_type,
+                              const gchar  *device_uri);
+
+gchar      *printer_get_hostname (cups_ptype_t  printer_type,
+                                  const gchar  *device_uri,
+                                  const gchar  *printer_uri);
+
+typedef void (*PSPCallback) (const gchar *printer_name,
+                             gboolean  success,
+                             gpointer  user_data);
+
+void        printer_set_ppd_async (const gchar  *printer_name,
+                                   const gchar  *ppd_name,
+                                   GCancellable *cancellable,
+                                   PSPCallback   callback,
+                                   gpointer      user_data);
+
+void        printer_set_ppd_file_async (const gchar *printer_name,
+                                        const gchar *ppd_filename,
+                                        GCancellable *cancellable,
+                                        PSPCallback   callback,
+                                        gpointer      user_data);
+
+typedef void (*GPNCallback) (PPDName     **names,
+                             const gchar  *printer_name,
+                             gboolean      cancelled,
+                             gpointer      user_data);
+
+void        get_ppd_names_async (gchar        *printer_name,
+                                 gint          count,
+                                 GCancellable *cancellable,
+                                 GPNCallback   callback,
+                                 gpointer      user_data);
+
+typedef void (*GAPCallback) (PPDList  *ppds,
+                             gpointer  user_data);
+
+void        get_all_ppds_async (GCancellable *cancellable,
+                                GAPCallback   callback,
+                                gpointer      user_data);
+
+PPDList    *ppd_list_copy (PPDList *list);
+void        ppd_list_free (PPDList *list);
+
+enum
+{
+  IPP_ATTRIBUTE_TYPE_INTEGER = 0,
+  IPP_ATTRIBUTE_TYPE_STRING,
+  IPP_ATTRIBUTE_TYPE_RANGE,
+  IPP_ATTRIBUTE_TYPE_BOOLEAN
+};
+
+typedef struct
+{
+  gboolean  boolean_value;
+  gchar    *string_value;
+  gint      integer_value;
+  gint      lower_range;
+  gint      upper_range;
+} IPPAttributeValue;
+
+typedef struct
+{
+  gchar             *attribute_name;
+  IPPAttributeValue *attribute_values;
+  gint               num_of_values;
+  gint               attribute_type;
+} IPPAttribute;
+
+typedef void (*GIACallback) (GHashTable *table,
+                             gpointer    user_data);
+
+void        get_ipp_attributes_async (const gchar  *printer_name,
+                                      gchar       **attributes_names,
+                                      GIACallback   callback,
+                                      gpointer      user_data);
+
+IPPAttribute *ipp_attribute_copy (IPPAttribute *attr);
+
+void        ipp_attribute_free (IPPAttribute *attr);
+
+gchar      *get_standard_manufacturers_name (const gchar *name);
+
+typedef void (*PGPCallback) (const gchar *ppd_filename,
+                             gpointer     user_data);
+
+void        printer_get_ppd_async (const gchar *printer_name,
+                                   const gchar *host_name,
+                                   gint         port,
+                                   PGPCallback  callback,
+                                   gpointer     user_data);
+
+/* NOTE: 'destination' is passed with ownership as cupsCopyDest doesn't seem to work as expected */
+typedef void (*GNDCallback) (cups_dest_t *destination,
+                             gpointer     user_data);
+
+void        get_named_dest_async (const gchar *printer_name,
+                                  GNDCallback  callback,
+                                  gpointer     user_data);
+
+typedef void (*PAOCallback) (gboolean success,
+                             gpointer user_data);
+
+void        printer_add_option_async (const gchar   *printer_name,
+                                      const gchar   *option_name,
+                                      gchar        **values,
+                                      gboolean       set_default,
+                                      GCancellable  *cancellable,
+                                      PAOCallback    callback,
+                                      gpointer       user_data);
+
+const gchar *get_page_size_from_locale (void);
+
+typedef void (*GCDCallback) (GPtrArray      *devices,
+                             gboolean        finished,
+                             gboolean        cancelled,
+                             gpointer        user_data);
+
+void        get_cups_devices_async (GCancellable *cancellable,
+                                    GCDCallback   callback,
+                                    gpointer      user_data);
+
+gchar      *guess_device_hostname (PpPrintDevice *device);
+
+gchar      *canonicalize_device_name (GList         *device_names,
+                                      GPtrArray     *local_cups_devices,
+                                      cups_dest_t   *dests,
+                                      gint           num_of_dests,
+                                      PpPrintDevice *device);
+
+void        shift_string_left (gchar *str);
+
+gboolean    printer_name_is_valid (const gchar *str);
+
+G_END_DECLS
diff --git a/panels/printers/ppd-selection-dialog.ui b/panels/printers/ppd-selection-dialog.ui
new file mode 100644
index 0000000..5408792
--- /dev/null
+++ b/panels/printers/ppd-selection-dialog.ui
@@ -0,0 +1,106 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!-- Generated with glade 3.18.3 -->
+<interface>
+  <requires lib="gtk+" version="3.12"/>
+  <template class="PpPPDSelectionDialog" parent="GtkDialog">
+    <property name="width_request">600</property>
+    <property name="height_request">400</property>
+    <property name="title" translatable="yes">Select Printer Driver</property>
+    <property name="modal">True</property>
+    <property name="destroy_with_parent">True</property>
+    <child>
+      <object class="GtkBox" id="main-vbox">
+        <property name="orientation">vertical</property>
+        <property name="spacing">10</property>
+        <property name="margin_top">10</property>
+        <property name="margin_start">10</property>
+        <property name="margin_end">10</property>
+        <child>
+          <object class="GtkBox" id="box3">
+            <property name="hexpand">True</property>
+            <property name="vexpand">True</property>
+            <property name="spacing">10</property>
+            <property name="halign">fill</property>
+            <child>
+              <object class="GtkScrolledWindow" id="scrolledwindow1">
+                <property name="width_request">140</property>
+                <property name="hscrollbar_policy">never</property>
+                <property name="halign">fill</property>
+                <property name="has_frame">True</property>
+                <child>
+                  <object class="GtkTreeView" id="ppd_selection_manufacturers_treeview">
+                    <child internal-child="selection">
+                      <object class="GtkTreeSelection" id="treeview-selection"/>
+                    </child>
+                  </object>
+                </child>
+              </object>
+            </child>
+            <child>
+              <object class="GtkScrolledWindow" id="scrolledwindow2">
+                <property name="hexpand">True</property>
+                <property name="halign">fill</property>
+                <property name="has_frame">True</property>
+                <child>
+                  <object class="GtkTreeView" id="ppd_selection_models_treeview">
+                    <child internal-child="selection">
+                      <object class="GtkTreeSelection" id="treeview-selection1"/>
+                    </child>
+                  </object>
+                </child>
+              </object>
+            </child>
+          </object>
+        </child>
+        <child>
+          <object class="GtkBox" id="dialog-action-area1">
+            <property name="halign">fill</property>
+            <property name="hexpand">True</property>
+            <property name="spacing">10</property>
+            <property name="margin_bottom">10</property>
+            <child>
+              <object class="GtkBox" id="box2">
+                <property name="halign">fill</property>
+                <property name="hexpand">True</property>
+                <property name="spacing">10</property>
+                <child>
+                  <object class="GtkSpinner" id="ppd_spinner">
+                    <property name="width_request">24</property>
+                    <property name="height_request">24</property>
+                    <property name="halign">fill</property>
+                  </object>
+                </child>
+                <child>
+                  <object class="GtkLabel" id="progress_label">
+                    <property name="label" translatable="yes">Loading drivers database…</property>
+                    <property name="halign">fill</property>
+                  </object>
+                </child>
+              </object>
+            </child>
+            <child>
+              <object class="GtkButton" id="ppd_selection_cancel_button">
+                <property name="label" translatable="yes">Cancel</property>
+                <property name="receives_default">True</property>
+                <property name="receives_default">True</property>
+                <property name="halign">end</property>
+              </object>
+            </child>
+            <child>
+              <object class="GtkButton" id="ppd_selection_select_button">
+                <property name="label" translatable="yes">Select</property>
+                <property name="sensitive">False</property>
+                <property name="receives_default">True</property>
+                <property name="halign">end</property>
+              </object>
+            </child>
+          </object>
+        </child>
+      </object>
+    </child>
+    <action-widgets>
+      <action-widget response="-6">ppd_selection_cancel_button</action-widget>
+      <action-widget response="-5">ppd_selection_select_button</action-widget>
+    </action-widgets>
+  </template>
+</interface>
diff --git a/panels/printers/printer-entry.ui b/panels/printers/printer-entry.ui
new file mode 100644
index 0000000..37fe3e0
--- /dev/null
+++ b/panels/printers/printer-entry.ui
@@ -0,0 +1,319 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<interface>
+  <!-- interface-requires gtk+ 3.8 -->
+  <object class="GtkPopover" id="printer-menu">
+    <style>
+      <class name="menu" />
+    </style>
+
+    <child>
+      <object class="GtkGrid">
+        <property name="margin-top">10</property>
+        <property name="margin-bottom">10</property>
+        <property name="margin-start">10</property>
+        <property name="margin-end">10</property>
+
+        <child>
+          <object class="GtkModelButton">
+            <property name="text" translatable="yes">Printing Options</property>
+            <signal name="clicked" handler="on_show_printer_options_dialog"/>
+            <layout>
+              <property name="column">1</property>
+              <property name="row">0</property>
+            </layout>
+          </object>
+        </child>
+
+        <child>
+          <object class="GtkModelButton">
+            <property name="text" translatable="yes">Printer Details</property>
+            <signal name="clicked" handler="on_show_printer_details_dialog"/>
+            <layout>
+              <property name="column">1</property>
+              <property name="row">1</property>
+            </layout>
+          </object>
+        </child>
+        <child>
+          <object class="GtkCheckButton" id="printer_default_checkbutton">
+            <property name="valign">center</property>
+            <property name="label" translatable="yes" comments="Set this printer as default">Use Printer by Default</property>
+            <signal name="toggled" handler="set_as_default_printer"/>
+            <layout>
+              <property name="column">0</property>
+              <property name="row">2</property>
+              <property name="column-span">3</property>
+            </layout>
+          </object>
+        </child>
+        <child>
+          <object class="GtkModelButton" id="clean_heads_menuitem">
+            <property name="visible">False</property>
+            <property name="text" translatable="yes" comments="Translators: This button executes command which cleans print heads of the printer.">Clean Print Heads</property>
+            <signal name="clicked" handler="clean_heads"/>
+            <layout>
+              <property name="column">1</property>
+              <property name="row">3</property>
+            </layout>
+          </object>
+        </child>
+        <child>
+          <object class="GtkModelButton" id="remove_printer_menuitem">
+            <property name="text" translatable="yes">Remove Printer</property>
+            <signal name="clicked" handler="remove_printer"/>
+            <layout>
+              <property name="column">1</property>
+              <property name="row">4</property>
+            </layout>
+          </object>
+        </child>
+      </object>
+    </child>
+  </object>
+
+  <template class="PpPrinterEntry" parent="GtkListBoxRow">
+    <property name="valign">center</property>
+    <property name="margin-top">10</property>
+    <property name="margin-bottom">10</property>
+    <property name="margin-start">60</property>
+    <property name="margin-end">60</property>
+    <property name="activatable">False</property>
+    <property name="hexpand">True</property>
+
+    <child>
+      <object class="GtkFrame" id="content_area">
+        <property name="valign">start</property>
+        <style>
+          <class name="view"/>
+        </style>
+
+        <child>
+          <object class="GtkGrid">
+            <property name="row-spacing">8</property>
+            <property name="column-spacing">15</property>
+            <property name="margin_start">24</property>
+            <property name="margin_end">20</property>
+            <property name="margin_top">14</property>
+            <property name="margin_bottom">20</property>
+
+            <child>
+              <object class="GtkImage" id="printer_icon">
+                <property name="pixel-size">48</property>
+                <property name="icon_name">printer</property>
+                <property name="valign">center</property>
+                <property name="halign">center</property>
+                <layout>
+                  <property name="column">0</property>
+                  <property name="row">0</property>
+                </layout>
+              </object>
+            </child>
+
+            <child>
+              <object class="GtkGrid" id="printer_name_grid">
+                <property name="margin-top">10</property>
+                <property name="margin-bottom">10</property>
+                <property name="margin_start">0</property>
+                <property name="margin-end">10</property>
+                <property name="halign">start</property>
+                <layout>
+                  <property name="column">1</property>
+                  <property name="row">0</property>
+                </layout>
+                <child>
+
+                  <object class="GtkLabel" id="printer_name_label">
+                    <property name="hexpand">True</property>
+                    <property name="halign">start</property>
+                    <property name="ellipsize">PANGO_ELLIPSIZE_MIDDLE</property>
+                    <property name="width-chars">22</property>
+                    <property name="xalign">0</property>
+                    <layout>
+                      <property name="column">0</property>
+                      <property name="row">0</property>
+                    </layout>
+                    <attributes>
+                      <attribute name="weight" value="bold"/>
+                      <attribute name="scale" value="1.2"/>
+                    </attributes>
+                  </object>
+                </child>
+
+                <child>
+                  <object class="GtkLabel" id="printer_status">
+                    <property name="halign">start</property>
+                    <layout>
+                      <property name="column">0</property>
+                      <property name="row">1</property>
+                    </layout>
+                  </object>
+                </child>
+              </object>
+            </child>
+
+            <child>
+              <object class="GtkBox">
+                <property name="spacing">12</property>
+                <property name="orientation">horizontal</property>
+                <property name="valign">center</property>
+                <layout>
+                  <property name="column">2</property>
+                  <property name="row">0</property>
+                </layout>
+                <child>
+
+                  <object class="GtkButton" id="show_jobs_dialog_button">
+                    <property name="sensitive">False</property>
+                    <property name="label" translatable="yes">No Active Jobs</property>
+                    <signal name="clicked" handler="show_jobs_dialog"/>
+                  </object>
+                </child>
+
+                <child>
+                  <object class="GtkMenuButton">
+                    <property name="popover">printer-menu</property>
+                    <property name="icon_name">emblem-system-symbolic</property>
+                  </object>
+                </child>
+              </object>
+            </child>
+
+            <child>
+              <object class="GtkLabel" id="printer_model_label">
+                <property name="label" translatable="yes">Model</property>
+                <property name="ellipsize">PANGO_ELLIPSIZE_MIDDLE</property>
+                <property name="halign">end</property>
+                <property name="xalign">1</property>
+                <layout>
+                  <property name="column">0</property>
+                  <property name="row">1</property>
+                </layout>
+                <style>
+                  <class name="dim-label"/>
+                </style>
+              </object>
+            </child>
+
+            <child>
+              <object class="GtkLabel" id="printer_model">
+                <property name="halign">start</property>
+                <property name="ellipsize">PANGO_ELLIPSIZE_MIDDLE</property>
+                <property name="xalign">0</property>
+                <layout>
+                  <property name="column">1</property>
+                  <property name="row">1</property>
+                </layout>
+              </object>
+            </child>
+
+            <child>
+              <object class="GtkLabel" id="printer_location_label">
+                <property name="label" translatable="yes">Location</property>
+                <property name="halign">end</property>
+                <property name="xalign">1</property>
+                <layout>
+                  <property name="column">0</property>
+                  <property name="row">2</property>
+                </layout>
+                <style>
+                  <class name="dim-label"/>
+                </style>
+              </object>
+            </child>
+
+            <child>
+              <object class="GtkLabel" id="printer_location_address_label">
+                <property name="halign">start</property>
+                <property name="ellipsize">PANGO_ELLIPSIZE_MIDDLE</property>
+                <property name="xalign">0</property>
+                <layout>
+                  <property name="column">1</property>
+                  <property name="row">2</property>
+                </layout>
+              </object>
+            </child>
+
+            <child>
+              <object class="GtkLabel" id="printer_inklevel_label">
+                <property name="label" translatable="yes">Ink Level</property>
+                <property name="halign">end</property>
+                <property name="xalign">1</property>
+                <layout>
+                  <property name="column">0</property>
+                  <property name="row">3</property>
+                </layout>
+                <style>
+                  <class name="dim-label"/>
+                </style>
+              </object>
+            </child>
+
+            <child>
+              <object class="GtkFrame" id="supply_frame">
+                <property name="valign">center</property>
+                <property name="halign">start</property>
+                <property name="height_request">18</property>
+                <property name="width_request">300</property>
+                <layout>
+                  <property name="column">1</property>
+                  <property name="row">3</property>
+                  <property name="column-span">2</property>
+                </layout>
+
+                <child>
+                  <object class="GtkDrawingArea" id="supply_drawing_area">
+                  </object>
+                </child>
+              </object>
+            </child>
+
+            <child>
+              <object class="GtkBox" id="printer_error">
+                <property name="visible">False</property>
+                <property name="spacing">10</property>
+                <property name="margin-top">6</property>
+                <layout>
+                  <property name="column">0</property>
+                  <property name="row">4</property>
+                  <property name="column-span">3</property>
+                </layout>
+
+                <child>
+                  <object class="GtkImage">
+                    <property name="icon_name">dialog-warning-symbolic</property>
+                  </object>
+                </child>
+
+                <child>
+                  <object class="GtkLabel" id="error_status">
+                    <property name="halign">start</property>
+                    <attributes>
+                      <attribute name="weight" value="bold"/>
+                    </attributes>
+                  </object>
+                </child>
+
+                <child>
+                  <object class="GtkLabel">
+                    <property name="hexpand">True</property>
+                    <property name="halign">start</property>
+                    <property name="label" translatable="yes" comments="Translators: This is the message which follows the printer error.">Please restart when the problem is resolved.</property>
+                  </object>
+                </child>
+
+                <child>
+                  <object class="GtkButton">
+                    <property name="label" translatable="yes" comments="Translators: This is the button which restarts the printer.">Restart</property>
+                    <signal name="clicked" handler="restart_printer"/>
+                  </object>
+                </child>
+
+              </object>
+            </child>
+          </object>
+        </child>
+     </object>
+    </child>
+  </template>
+
+</interface>
diff --git a/panels/printers/printers.gresource.xml b/panels/printers/printers.gresource.xml
new file mode 100644
index 0000000..cecce18
--- /dev/null
+++ b/panels/printers/printers.gresource.xml
@@ -0,0 +1,13 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<gresources>
+  <gresource prefix="/org/gnome/control-center/printers">
+    <file preprocess="xml-stripblanks">new-printer-dialog.ui</file>
+    <file preprocess="xml-stripblanks">pp-options-dialog.ui</file>
+    <file preprocess="xml-stripblanks">ppd-selection-dialog.ui</file>
+    <file preprocess="xml-stripblanks">pp-details-dialog.ui</file>
+    <file preprocess="xml-stripblanks">pp-job-row.ui</file>
+    <file preprocess="xml-stripblanks">pp-jobs-dialog.ui</file>
+    <file preprocess="xml-stripblanks">printer-entry.ui</file>
+    <file preprocess="xml-stripblanks">printers.ui</file>
+  </gresource>
+</gresources>
diff --git a/panels/printers/printers.ui b/panels/printers/printers.ui
new file mode 100644
index 0000000..128c26e
--- /dev/null
+++ b/panels/printers/printers.ui
@@ -0,0 +1,242 @@
+<?xml version="1.0"?>
+<interface>
+  <requires lib="gtk+" version="3.12"/>
+  <object class="GtkBox" id="top-right-buttons">
+    <property name="spacing">6</property>
+    <child>
+      <object class="GtkButton" id="printer-add-button">
+        <property name="sensitive">False</property>
+        <property name="use_underline">True</property>
+        <property name="label" translatable="yes" comments="Translators: This button adds new printer.">Add Printer…</property>
+        <style>
+          <class name="suggested-action"/>
+        </style>
+      </object>
+    </child>
+    <child>
+      <object class="GtkToggleButton" id="search-button">
+        <property name="margin-end">6</property> <!-- since we don't have access to the shell header bar -->
+        <property name="icon_name">edit-find-symbolic</property>
+        <style>
+          <class name="image-button"/>
+        </style>
+      </object>
+    </child>
+  </object>
+
+<object class="GtkOverlay" id="overlay">
+  <child type="overlay">
+    <object class="GtkRevealer" id="notification">
+      <property name="halign">GTK_ALIGN_CENTER</property>
+      <property name="valign">GTK_ALIGN_START</property>
+      <child>
+        <object class="GtkBox">
+          <property name="spacing">6</property>
+          <style>
+            <class name="app-notification"/>
+          </style>
+          <child>
+            <object class="GtkLabel" id="notification-label">
+              <property name="wrap">True</property>
+              <property name="max_width_chars">50</property>
+            </object>
+          </child>
+          <child>
+            <object class="GtkButton" id="notification-undo-button">
+              <property name="valign">GTK_ALIGN_CENTER</property>
+              <property name="label" translatable="yes" comments="Translators: This is the button which allows undoing the removal of the printer.">Undo</property>
+            </object>
+          </child>
+          <child>
+            <object class="GtkButton" id="notification-dismiss-button">
+              <property name="valign">GTK_ALIGN_CENTER</property>
+              <property name="icon_name">window-close-symbolic</property>
+              <style>
+                <class name="flat"/>
+              </style>
+            </object>
+          </child>
+        </object>
+      </child>
+    </object>
+  </child>
+  <child>
+
+<object class="GtkBox">
+  <property name="orientation">GTK_ORIENTATION_VERTICAL</property>
+  <child>
+    <object class="CcPermissionInfobar" id="permission-infobar">
+    </object>
+  </child>
+  <child>
+
+  <object class="GtkStack" id="main-vbox">
+    <property name="hexpand">True</property>
+    <property name="vexpand">True</property>
+
+    <child>
+      <object class="GtkStackPage">
+        <property name="name">loading-page</property>
+        <property name="child">
+          <object class="GtkBox">
+            <child>
+              <object class="GtkSpinner" id="loading-spinner">
+                <property name="spinning">True</property>
+                <property name="hexpand">True</property>
+                <property name="vexpand">True</property>
+                <property name="halign">center</property>
+                <property name="valign">center</property>
+              </object>
+            </child>
+          </object>
+        </property>
+      </object>
+    </child>
+
+    <child>
+      <object class="GtkStackPage">
+        <property name="name">printers-list</property>
+        <property name="child">
+          <object class="GtkBox">
+            <property name="orientation">vertical</property>
+            <child>
+              <object class="GtkSearchBar" id="search-bar">
+                <property name="hexpand">True</property>
+                <property name="search_mode_enabled" bind-source="search-button" bind-property="active" bind-flags="bidirectional" />
+                <child>
+                  <object class="GtkSearchEntry" id="search-entry">
+                    <property name="width_chars">30</property>
+                  </object>
+                </child>
+              </object>
+            </child>
+            <child>
+              <object class="GtkScrolledWindow" id="scrolled-window">
+                <property name="hscrollbar-policy">never</property>
+                <property name="min-content-height">490</property>
+                <property name="vexpand">True</property>
+                <child>
+                  <object class="GtkBox">
+                    <child>
+                      <object class="GtkListBox" id="content">
+                        <property name="selection-mode">GTK_SELECTION_NONE</property>
+                        <property name="margin-top">32</property>
+                        <property name="margin-bottom">32</property>
+                        <style>
+                          <class name="background"/>
+                        </style>
+                      </object>
+                    </child>
+                  </object>
+                </child>
+              </object>
+            </child>
+          </object>
+        </property>
+      </object>
+    </child>
+
+    <child>
+      <object class="GtkStackPage">
+        <property name="name">empty-state</property>
+        <property name="child">
+          <object class="GtkBox">
+            <property name="spacing">10</property>
+            <property name="orientation">vertical</property>
+            <property name="valign">center</property>
+            <child>
+              <object class="GtkImage">
+                <property name="valign">start</property>
+                <property name="pixel_size">80</property>
+                <property name="icon_name">printer-symbolic</property>
+                <style>
+                  <class name="dim-label"/>
+                </style>
+              </object>
+            </child>
+            <child>
+              <object class="GtkLabel">
+                <property name="margin_bottom">15</property>
+                <property name="label" translatable="yes">No printers</property>
+                <style>
+                  <class name="dim-label"/>
+                </style>
+                <attributes>
+                  <attribute name="scale" value="1.2"/>
+                </attributes>
+              </object>
+            </child>
+            <child>
+              <object class="GtkButton" id="printer-add-button2">
+                <property name="label" translatable="yes" comments="Translators: This button adds new printer.">Add Printer…</property>
+                <property name="receives_default">True</property>
+                <property name="halign">center</property>
+                <style>
+                  <class name="suggested-action"/>
+                </style>
+              </object>
+            </child>
+          </object>
+        </property>
+      </object>
+    </child>
+
+    <child>
+      <object class="GtkStackPage">
+        <property name="name">no-cups-page</property>
+        <property name="child">
+          <object class="GtkBox">
+            <property name="spacing">10</property>
+            <property name="orientation">vertical</property>
+            <property name="valign">center</property>
+            <child>
+              <object class="GtkLabel">
+                <property name="hexpand">True</property>
+                <property name="vexpand">True</property>
+                <property name="label" translatable="yes" comments="Translators: The CUPS server is not running (we can not connect to it).">Sorry! The system printing service
+    doesn’t seem to be available.</property>
+                <style>
+                  <class name="dim-label"/>
+                </style>
+                <attributes>
+                    <attribute name="scale" value="1.2"/>
+                </attributes>
+              </object>
+            </child>
+            <child>
+              <object class="GtkImage">
+                <property name="hexpand">True</property>
+                <property name="vexpand">True</property>
+                <property name="valign">start</property>
+                <property name="pixel_size">80</property>
+                <property name="icon_name">computer-fail-symbolic</property>
+                <style>
+                  <class name="dim-label"/>
+                </style>
+              </object>
+            </child>
+          </object>
+        </property>
+      </object>
+    </child>
+
+  </object>
+</child>
+</object>
+
+  </child>
+</object>
+
+  <object class="GtkSizeGroup" id="sizegroup1">
+   <widgets>
+      <widget name="back-button-1"/>
+      <widget name="back-spacer-label-1"/>
+   </widgets>
+  </object>
+  <object class="GtkSizeGroup" id="sizegroup2">
+   <widgets>
+      <widget name="back-button-2"/>
+      <widget name="back-spacer-label-2"/>
+   </widgets>
+  </object>
+</interface>