/* GtkPrintUnixDialog

 * Copyright (C) 2006 John (J5) Palmieri  <johnp@redhat.com>

 * Copyright (C) 2006 Alexander Larsson <alexl@redhat.com>

 * Copyright © 2006, 2007 Christian Persch

 *

 * This library is free software; you can redistribute it and/or

 * modify it under the terms of the GNU Lesser General Public

 * License as published by the Free Software Foundation; either

 * version 2 of the License, or (at your option) any later version.

 *

 * This library 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

 * Lesser General Public License for more details.

 *

 * You should have received a copy of the GNU Lesser General Public

 * License along with this library; if not, write to the

 * Free Software Foundation, Inc., 59 Temple Place - Suite 330,

 * Boston, MA 02111-1307, USA.

 */

#include "config.h"

#include <stdlib.h>

#include <string.h>

#include <ctype.h>

#include <stdio.h>

#include <math.h>

#include "gtkintl.h"

#include "gtkprivate.h"

#include "gtkspinbutton.h"

#include "gtkcellrendererpixbuf.h"

#include "gtkcellrenderertext.h"

#include "gtkstock.h"

#include "gtkiconfactory.h"

#include "gtkimage.h"

#include "gtktreeselection.h"

#include "gtknotebook.h"

#include "gtkscrolledwindow.h"

#include "gtkcombobox.h"

#include "gtktogglebutton.h"

#include "gtkradiobutton.h"

#include "gtkdrawingarea.h"

#include "gtkvbox.h"

#include "gtktable.h"

#include "gtkframe.h"

#include "gtkalignment.h"

#include "gtklabel.h"

#include "gtkeventbox.h"

#include "gtkbuildable.h"

#include "gtkcustompaperunixdialog.h"

#include "gtkprintbackend.h"

#include "gtkprinter-private.h"

#include "gtkprintunixdialog.h"

#include "gtkprinteroptionwidget.h"

#include "gtkprintutils.h"

#include "gtkalias.h"

#include "gtkmessagedialog.h"

#include "gtkbutton.h"

#define EXAMPLE_PAGE_AREA_SIZE 110

#define RULER_DISTANCE 7.5

#define RULER_RADIUS 2

#define GTK_PRINT_UNIX_DIALOG_GET_PRIVATE(o)  \

   (G_TYPE_INSTANCE_GET_PRIVATE ((o), GTK_TYPE_PRINT_UNIX_DIALOG, GtkPrintUnixDialogPrivate))

static void     gtk_print_unix_dialog_destroy      (GtkPrintUnixDialog *dialog);

static void     gtk_print_unix_dialog_finalize     (GObject            *object);

static void     gtk_print_unix_dialog_set_property (GObject            *object,

                                                    guint               prop_id,

                                                    const GValue       *value,

                                                    GParamSpec         *pspec);

static void     gtk_print_unix_dialog_get_property (GObject            *object,

                                                    guint               prop_id,

                                                    GValue             *value,

                                                    GParamSpec         *pspec);

static void     gtk_print_unix_dialog_style_set    (GtkWidget          *widget,

                                                    GtkStyle           *previous_style);

static void     populate_dialog                    (GtkPrintUnixDialog *dialog);

static void     unschedule_idle_mark_conflicts     (GtkPrintUnixDialog *dialog);

static void     selected_printer_changed           (GtkTreeSelection   *selection,

                                                    GtkPrintUnixDialog *dialog);

static void     clear_per_printer_ui               (GtkPrintUnixDialog *dialog);

static void     printer_added_cb                   (GtkPrintBackend    *backend,

                                                    GtkPrinter         *printer,

                                                    GtkPrintUnixDialog *dialog);

static void     printer_removed_cb                 (GtkPrintBackend    *backend,

                                                    GtkPrinter         *printer,

                                                    GtkPrintUnixDialog *dialog);

static void     printer_status_cb                  (GtkPrintBackend    *backend,

                                                    GtkPrinter         *printer,

                                                    GtkPrintUnixDialog *dialog);

static void     update_collate_icon                (GtkToggleButton    *toggle_button,

                                                    GtkPrintUnixDialog *dialog);

static gboolean dialog_get_collate                 (GtkPrintUnixDialog *dialog);

static gboolean dialog_get_reverse                 (GtkPrintUnixDialog *dialog);

static gint     dialog_get_n_copies                (GtkPrintUnixDialog *dialog);

static void     set_cell_sensitivity_func          (GtkTreeViewColumn *tree_column,

                                                    GtkCellRenderer   *cell,

                                                    GtkTreeModel      *model,

                                                    GtkTreeIter       *iter,

                                                    gpointer           data);

static gboolean set_active_printer                 (GtkPrintUnixDialog *dialog,

                                                    const gchar        *printer_name);

static void redraw_page_layout_preview             (GtkPrintUnixDialog *dialog);

/* GtkBuildable */

static void gtk_print_unix_dialog_buildable_init                    (GtkBuildableIface *iface);

static GObject *gtk_print_unix_dialog_buildable_get_internal_child  (GtkBuildable *buildable,

                                                                     GtkBuilder   *builder,

                                                                     const gchar  *childname);

static const gchar const common_paper_sizes[][16] = {

  "na_letter",

  "na_legal",

  "iso_a4",

  "iso_a5",

  "roc_16k",

  "iso_b5",

  "jis_b5",

  "na_number-10",

  "iso_dl",

  "jpn_chou3",

  "na_ledger",

  "iso_a3",

};

enum {

  PAGE_SETUP_LIST_COL_PAGE_SETUP,

  PAGE_SETUP_LIST_COL_IS_SEPARATOR,

  PAGE_SETUP_LIST_N_COLS

};

enum {

  PROP_0,

  PROP_PAGE_SETUP,

  PROP_CURRENT_PAGE,

  PROP_PRINT_SETTINGS,

  PROP_SELECTED_PRINTER,

  PROP_MANUAL_CAPABILITIES,

  PROP_SUPPORT_SELECTION,

  PROP_HAS_SELECTION,

  PROP_EMBED_PAGE_SETUP

};

enum {

  PRINTER_LIST_COL_ICON,

  PRINTER_LIST_COL_NAME,

  PRINTER_LIST_COL_STATE,

  PRINTER_LIST_COL_JOBS,

  PRINTER_LIST_COL_LOCATION,

  PRINTER_LIST_COL_PRINTER_OBJ,

  PRINTER_LIST_N_COLS

};

struct GtkPrintUnixDialogPrivate

{

  GtkWidget *notebook;

  GtkWidget *printer_treeview;

  GtkPrintCapabilities manual_capabilities;

  GtkPrintCapabilities printer_capabilities;

  GtkTreeModel *printer_list;

  GtkTreeModelFilter *printer_list_filter;

  GtkPageSetup *page_setup;

  gboolean page_setup_set;

  gboolean embed_page_setup;

  GtkListStore *page_setup_list;

  GtkListStore *custom_paper_list;

  gboolean support_selection;

  gboolean has_selection;

  GtkWidget *all_pages_radio;

  GtkWidget *current_page_radio;

  GtkWidget *selection_radio;

  GtkWidget *range_table;

  GtkWidget *page_range_radio;

  GtkWidget *page_range_entry;

  GtkWidget *copies_spin;

  GtkWidget *collate_check;

  GtkWidget *reverse_check;

  GtkWidget *collate_image;

  GtkWidget *page_layout_preview;

  GtkWidget *scale_spin;

  GtkWidget *page_set_combo;

  GtkWidget *print_now_radio;

  GtkWidget *print_at_radio;

  GtkWidget *print_at_entry;

  GtkWidget *print_hold_radio;

  GtkWidget *preview_button;

  GtkWidget *paper_size_combo;

  GtkWidget *paper_size_combo_label;

  GtkWidget *orientation_combo;

  GtkWidget *orientation_combo_label;

  gboolean internal_page_setup_change;

  gboolean updating_print_at;

  GtkPrinterOptionWidget *pages_per_sheet;

  GtkPrinterOptionWidget *duplex;

  GtkPrinterOptionWidget *paper_type;

  GtkPrinterOptionWidget *paper_source;

  GtkPrinterOptionWidget *output_tray;

  GtkPrinterOptionWidget *job_prio;

  GtkPrinterOptionWidget *billing_info;

  GtkPrinterOptionWidget *cover_before;

  GtkPrinterOptionWidget *cover_after;

  GtkPrinterOptionWidget *number_up_layout;

  GtkWidget *conflicts_widget;

  GtkWidget *job_page;

  GtkWidget *finishing_table;

  GtkWidget *finishing_page;

  GtkWidget *image_quality_table;

  GtkWidget *image_quality_page;

  GtkWidget *color_table;

  GtkWidget *color_page;

  GtkWidget *advanced_vbox;

  GtkWidget *advanced_page;

  GtkWidget *extension_point;

  /* These are set initially on selected printer (either default printer,

   * printer taken from set settings, or user-selected), but when any

   * setting is changed by the user it is cleared.

   */

  GtkPrintSettings *initial_settings;

  GtkPrinterOption *number_up_layout_n_option;

  GtkPrinterOption *number_up_layout_2_option;

  /* This is the initial printer set by set_settings. We look for it in

   * the added printers. We clear this whenever the user manually changes

   * to another printer, when the user changes a setting or when we find

   * this printer.

   */

  char *waiting_for_printer;

  gboolean internal_printer_change;

  GList *print_backends;

  GtkPrinter *current_printer;

  GtkPrinter *request_details_printer;

  guint request_details_tag;

  GtkPrinterOptionSet *options;

  gulong options_changed_handler;

  gulong mark_conflicts_id;

  gchar *format_for_printer;

  gint current_page;

};

G_DEFINE_TYPE_WITH_CODE (GtkPrintUnixDialog, gtk_print_unix_dialog, GTK_TYPE_DIALOG,

                         G_IMPLEMENT_INTERFACE (GTK_TYPE_BUILDABLE,

                                                gtk_print_unix_dialog_buildable_init))

static GtkBuildableIface *parent_buildable_iface;

static gboolean

is_default_printer (GtkPrintUnixDialog *dialog,

                    GtkPrinter         *printer)

{

  GtkPrintUnixDialogPrivate *priv = dialog->priv;

  if (priv->format_for_printer)

    return strcmp (priv->format_for_printer,

                   gtk_printer_get_name (printer)) == 0;

 else

   return gtk_printer_is_default (printer);

}

static void

gtk_print_unix_dialog_class_init (GtkPrintUnixDialogClass *class)

{

  GObjectClass *object_class;

  GtkWidgetClass *widget_class;

  object_class = (GObjectClass *) class;

  widget_class = (GtkWidgetClass *) class;

  object_class->finalize = gtk_print_unix_dialog_finalize;

  object_class->set_property = gtk_print_unix_dialog_set_property;

  object_class->get_property = gtk_print_unix_dialog_get_property;

  widget_class->style_set = gtk_print_unix_dialog_style_set;

  g_object_class_install_property (object_class,

                                   PROP_PAGE_SETUP,

                                   g_param_spec_object ("page-setup",

                                                        P_("Page Setup"),

                                                        P_("The GtkPageSetup to use"),

                                                        GTK_TYPE_PAGE_SETUP,

                                                        GTK_PARAM_READWRITE));

  g_object_class_install_property (object_class,

                                   PROP_CURRENT_PAGE,

                                   g_param_spec_int ("current-page",

                                                     P_("Current Page"),

                                                     P_("The current page in the document"),

                                                     -1,

                                                     G_MAXINT,

                                                     -1,

                                                     GTK_PARAM_READWRITE));

  g_object_class_install_property (object_class,

                                   PROP_PRINT_SETTINGS,

                                   g_param_spec_object ("print-settings",

                                                        P_("Print Settings"),

                                                        P_("The GtkPrintSettings used for initializing the dialog"),

                                                        GTK_TYPE_PRINT_SETTINGS,

                                                        GTK_PARAM_READWRITE));

  g_object_class_install_property (object_class,

                                   PROP_SELECTED_PRINTER,

                                   g_param_spec_object ("selected-printer",

                                                        P_("Selected Printer"),

                                                        P_("The GtkPrinter which is selected"),

                                                        GTK_TYPE_PRINTER,

                                                        GTK_PARAM_READABLE));

  g_object_class_install_property (object_class,

                                   PROP_MANUAL_CAPABILITIES,

                                   g_param_spec_flags ("manual-capabilities",

                                                       P_("Manual Capabilites"),

                                                       P_("Capabilities the application can handle"),

                                                       GTK_TYPE_PRINT_CAPABILITIES,

                                                       0,

                                                       GTK_PARAM_READWRITE));

  g_object_class_install_property (object_class,

                                   PROP_SUPPORT_SELECTION,

                                   g_param_spec_boolean ("support-selection",

                                                         P_("Support Selection"),

                                                         P_("Whether the dialog supports selection"),

                                                         FALSE,

                                                         GTK_PARAM_READWRITE));

  g_object_class_install_property (object_class,

                                   PROP_HAS_SELECTION,

                                   g_param_spec_boolean ("has-selection",

                                                         P_("Has Selection"),

                                                         P_("Whether the application has a selection"),

                                                         FALSE,

                                                         GTK_PARAM_READWRITE));

   g_object_class_install_property (object_class,

 				   PROP_EMBED_PAGE_SETUP,

 				   g_param_spec_boolean ("embed-page-setup",

 							 P_("Embed Page Setup"),

 							 P_("TRUE if page setup combos are embedded in GtkPrintUnixDialog"),

 							 FALSE,

 							 GTK_PARAM_READWRITE));

  g_type_class_add_private (class, sizeof (GtkPrintUnixDialogPrivate));

}

/* Returns a toplevel GtkWindow, or NULL if none */

static GtkWindow *

get_toplevel (GtkWidget *widget)

{

  GtkWidget *toplevel = NULL;

  toplevel = gtk_widget_get_toplevel (widget);

  if (!gtk_widget_is_toplevel (toplevel))

    return NULL;

  else

    return GTK_WINDOW (toplevel);

}

static void

set_busy_cursor (GtkPrintUnixDialog *dialog,

		 gboolean            busy)

{

  GtkWindow *toplevel;

  GdkDisplay *display;

  GdkCursor *cursor;

  toplevel = get_toplevel (GTK_WIDGET (dialog));

  if (!toplevel || !gtk_widget_get_realized (GTK_WIDGET (toplevel)))

    return;

  display = gtk_widget_get_display (GTK_WIDGET (toplevel));

  if (busy)

    cursor = gdk_cursor_new_for_display (display, GDK_WATCH);

  else

    cursor = NULL;

  gdk_window_set_cursor (GTK_WIDGET (toplevel)->window, cursor);

  gdk_display_flush (display);

  if (cursor)

    gdk_cursor_unref (cursor);

}

static void

add_custom_button_to_dialog (GtkDialog   *dialog,

                             const gchar *mnemonic_label,

                             const gchar *stock_id,

                             gint         response_id)

{

  GtkWidget *button = NULL;

  button = gtk_button_new_with_mnemonic (mnemonic_label);

  gtk_widget_set_can_default (button, TRUE);

  gtk_button_set_image (GTK_BUTTON (button),

                        gtk_image_new_from_stock (stock_id,

                                                  GTK_ICON_SIZE_BUTTON));

  gtk_widget_show (button);

  gtk_dialog_add_action_widget (GTK_DIALOG (dialog), button, response_id);

}

/* This function handles error messages before printing.

 */

static gboolean

error_dialogs (GtkPrintUnixDialog *print_dialog,

               gint                print_dialog_response_id,

               gpointer            data)

{

  GtkPrintUnixDialogPrivate *priv = print_dialog->priv;

  GtkPrinterOption          *option = NULL;

  GtkPrinter                *printer = NULL;

  GtkWindow                 *toplevel = NULL;

  GtkWidget                 *dialog = NULL;

  GFile                     *file = NULL;

  gchar                     *basename = NULL;

  gchar                     *dirname = NULL;

  int                        response;

  if (print_dialog != NULL && print_dialog_response_id == GTK_RESPONSE_OK)

    {

      printer = gtk_print_unix_dialog_get_selected_printer (print_dialog);

      if (printer != NULL)

        {

          if (priv->request_details_tag || !gtk_printer_is_accepting_jobs (printer))

            {

              g_signal_stop_emission_by_name (print_dialog, "response");

              return TRUE;

            }

          /* Shows overwrite confirmation dialog in the case of printing to file which

           * already exists. */

          if (gtk_printer_is_virtual (printer))

            {

              option = gtk_printer_option_set_lookup (priv->options,

                                                      "gtk-main-page-custom-input");

              if (option != NULL &&

                  option->type == GTK_PRINTER_OPTION_TYPE_FILESAVE)

                {

                  file = g_file_new_for_uri (option->value);

                  if (file != NULL &&

                      g_file_query_exists (file, NULL))

                    {

                      toplevel = get_toplevel (GTK_WIDGET (print_dialog));

                      basename = g_file_get_basename (file);

                      dirname = g_file_get_parse_name (g_file_get_parent (file));

                      dialog = gtk_message_dialog_new (toplevel,

                                                       GTK_DIALOG_MODAL |

                                                       GTK_DIALOG_DESTROY_WITH_PARENT,

                                                       GTK_MESSAGE_QUESTION,

                                                       GTK_BUTTONS_NONE,

                                                       _("A file named \"%s\" already exists.  Do you want to replace it?"),

                                                       basename);

                      gtk_message_dialog_format_secondary_text (GTK_MESSAGE_DIALOG (dialog),

                                                                _("The file already exists in \"%s\".  Replacing it will "

                                                                "overwrite its contents."),

                                                                dirname);

                      gtk_dialog_add_button (GTK_DIALOG (dialog),

                                             GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL);

                      add_custom_button_to_dialog (GTK_DIALOG (dialog),

                                                   _("_Replace"),

                                                   GTK_STOCK_PRINT,

                                                   GTK_RESPONSE_ACCEPT);

                      gtk_dialog_set_alternative_button_order (GTK_DIALOG (dialog),

                                                               GTK_RESPONSE_ACCEPT,

                                                               GTK_RESPONSE_CANCEL,

                                                               -1);

                      gtk_dialog_set_default_response (GTK_DIALOG (dialog),

                                                       GTK_RESPONSE_ACCEPT);

                      if (toplevel->group)

                        gtk_window_group_add_window (toplevel->group,

                                                     GTK_WINDOW (dialog));

                      response = gtk_dialog_run (GTK_DIALOG (dialog));

                      gtk_widget_destroy (dialog);

                      g_free (dirname);

                      g_free (basename);

                      if (response != GTK_RESPONSE_ACCEPT)

                        {

                          g_signal_stop_emission_by_name (print_dialog, "response");

                          g_object_unref (file);

                          return TRUE;

                        }

                    }

                  g_object_unref (file);

                }

            }

        }

    }

  return FALSE;

}

static void

gtk_print_unix_dialog_init (GtkPrintUnixDialog *dialog)

{

  GtkPrintUnixDialogPrivate *priv = dialog->priv;

  priv = dialog->priv = GTK_PRINT_UNIX_DIALOG_GET_PRIVATE (dialog);

  priv->print_backends = NULL;

  priv->current_page = -1;

  priv->number_up_layout_n_option = NULL;

  priv->number_up_layout_2_option = NULL;

  priv->page_setup = gtk_page_setup_new ();

  priv->page_setup_set = FALSE;

  priv->embed_page_setup = FALSE;

  priv->internal_page_setup_change = FALSE;

  priv->support_selection = FALSE;

  priv->has_selection = FALSE;

  g_signal_connect (dialog,

                    "destroy",

                    (GCallback) gtk_print_unix_dialog_destroy,

                    NULL);

  g_signal_connect (dialog,

                    "response",

                    (GCallback) error_dialogs,

                    NULL);

  g_signal_connect (dialog,

                    "notify::page-setup",

                    (GCallback) redraw_page_layout_preview,

                    NULL);

  priv->preview_button = gtk_button_new_from_stock (GTK_STOCK_PRINT_PREVIEW);

  gtk_widget_show (priv->preview_button);

  gtk_dialog_add_action_widget (GTK_DIALOG (dialog),

                                priv->preview_button,

                                GTK_RESPONSE_APPLY);

  gtk_dialog_add_buttons (GTK_DIALOG (dialog),

                          GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,

                          GTK_STOCK_PRINT, GTK_RESPONSE_OK,

                          NULL);

  gtk_dialog_set_alternative_button_order (GTK_DIALOG (dialog),

                                           GTK_RESPONSE_APPLY,

                                           GTK_RESPONSE_OK,

                                           GTK_RESPONSE_CANCEL,

                                           -1);

  gtk_dialog_set_default_response (GTK_DIALOG (dialog), GTK_RESPONSE_OK);

  gtk_dialog_set_response_sensitive (GTK_DIALOG (dialog), GTK_RESPONSE_OK, FALSE);

  priv->page_setup_list = gtk_list_store_new (PAGE_SETUP_LIST_N_COLS,

                                              G_TYPE_OBJECT,

                                              G_TYPE_BOOLEAN);

  priv->custom_paper_list = gtk_list_store_new (1, G_TYPE_OBJECT);

  _gtk_print_load_custom_papers (priv->custom_paper_list);

  populate_dialog (dialog);

}

static void

gtk_print_unix_dialog_destroy (GtkPrintUnixDialog *dialog)

{

  /* Make sure we don't destroy custom widgets owned by the backends */

  clear_per_printer_ui (dialog);

}

static void

disconnect_printer_details_request (GtkPrintUnixDialog *dialog, gboolean details_failed)

{

  GtkPrintUnixDialogPrivate *priv = dialog->priv;

  if (priv->request_details_tag)

    {

      g_signal_handler_disconnect (priv->request_details_printer,

                                   priv->request_details_tag);

      priv->request_details_tag = 0;

      set_busy_cursor (dialog, FALSE);

      if (details_failed)

        gtk_list_store_set (GTK_LIST_STORE (priv->printer_list),

                            g_object_get_data (G_OBJECT (priv->request_details_printer),

                                               "gtk-print-tree-iter"),

                            PRINTER_LIST_COL_STATE,

                             _("Getting printer information failed"),

                            -1);

      else

        gtk_list_store_set (GTK_LIST_STORE (priv->printer_list),

                            g_object_get_data (G_OBJECT (priv->request_details_printer),

                                               "gtk-print-tree-iter"),

                            PRINTER_LIST_COL_STATE,

                            gtk_printer_get_state_message (priv->request_details_printer),

                            -1);

      g_object_unref (priv->request_details_printer);

      priv->request_details_printer = NULL;

    }

}

static void

gtk_print_unix_dialog_finalize (GObject *object)

{

  GtkPrintUnixDialog *dialog = GTK_PRINT_UNIX_DIALOG (object);

  GtkPrintUnixDialogPrivate *priv = dialog->priv;

  GtkPrintBackend *backend;

  GList *node;

  unschedule_idle_mark_conflicts (dialog);

  disconnect_printer_details_request (dialog, FALSE);

  if (priv->current_printer)

    {

      g_object_unref (priv->current_printer);

      priv->current_printer = NULL;

    }

  if (priv->printer_list)

    {

      g_object_unref (priv->printer_list);

      priv->printer_list = NULL;

    }

  if (priv->custom_paper_list)

    {

      g_object_unref (priv->custom_paper_list);

      priv->custom_paper_list = NULL;

    }

  if (priv->printer_list_filter)

    {

      g_object_unref (priv->printer_list_filter);

      priv->printer_list_filter = NULL;

    }

  if (priv->options)

    {

      g_object_unref (priv->options);

      priv->options = NULL;

    }

  if (priv->number_up_layout_2_option)

    {

      priv->number_up_layout_2_option->choices[0] = NULL;

      priv->number_up_layout_2_option->choices[1] = NULL;

      g_free (priv->number_up_layout_2_option->choices_display[0]);

      g_free (priv->number_up_layout_2_option->choices_display[1]);

      priv->number_up_layout_2_option->choices_display[0] = NULL;

      priv->number_up_layout_2_option->choices_display[1] = NULL;

      g_object_unref (priv->number_up_layout_2_option);

      priv->number_up_layout_2_option = NULL;

    }

  if (priv->number_up_layout_n_option)

    {

      g_object_unref (priv->number_up_layout_n_option);

      priv->number_up_layout_n_option = NULL;

    }

 if (priv->page_setup)

    {

      g_object_unref (priv->page_setup);

      priv->page_setup = NULL;

    }

  if (priv->initial_settings)

    {

      g_object_unref (priv->initial_settings);

      priv->initial_settings = NULL;

    }

  g_free (priv->waiting_for_printer);

  priv->waiting_for_printer = NULL;

  g_free (priv->format_for_printer);

  priv->format_for_printer = NULL;

  for (node = priv->print_backends; node != NULL; node = node->next)

    {

      backend = GTK_PRINT_BACKEND (node->data);

      g_signal_handlers_disconnect_by_func (backend, printer_added_cb, dialog);

      g_signal_handlers_disconnect_by_func (backend, printer_removed_cb, dialog);

      g_signal_handlers_disconnect_by_func (backend, printer_status_cb, dialog);

      gtk_print_backend_destroy (backend);

      g_object_unref (backend);

    }

  g_list_free (priv->print_backends);

  priv->print_backends = NULL;

  if (priv->page_setup_list)

    {

      g_object_unref (priv->page_setup_list);

      priv->page_setup_list = NULL;

    }

  G_OBJECT_CLASS (gtk_print_unix_dialog_parent_class)->finalize (object);

}

static void

printer_removed_cb (GtkPrintBackend    *backend,

                    GtkPrinter         *printer,

                    GtkPrintUnixDialog *dialog)

{

  GtkPrintUnixDialogPrivate *priv = dialog->priv;

  GtkTreeIter *iter;

  iter = g_object_get_data (G_OBJECT (printer), "gtk-print-tree-iter");

  gtk_list_store_remove (GTK_LIST_STORE (priv->printer_list), iter);

}

static void

gtk_print_unix_dialog_buildable_init (GtkBuildableIface *iface)

{

  parent_buildable_iface = g_type_interface_peek_parent (iface);

  iface->get_internal_child = gtk_print_unix_dialog_buildable_get_internal_child;

}

static GObject *

gtk_print_unix_dialog_buildable_get_internal_child (GtkBuildable *buildable,

                                                    GtkBuilder   *builder,

                                                    const gchar  *childname)

{

  if (strcmp (childname, "notebook") == 0)

    return G_OBJECT (GTK_PRINT_UNIX_DIALOG (buildable)->priv->notebook);

  return parent_buildable_iface->get_internal_child (buildable, builder, childname);

}

/* This function controls "sensitive" property of GtkCellRenderer based on pause

 * state of printers. */

void set_cell_sensitivity_func (GtkTreeViewColumn *tree_column,

                                GtkCellRenderer   *cell,

                                GtkTreeModel      *tree_model,

                                GtkTreeIter       *iter,

                                gpointer           data)

{

  GtkPrinter *printer;

  gtk_tree_model_get (tree_model, iter, PRINTER_LIST_COL_PRINTER_OBJ, &printer, -1);

  if (printer != NULL && !gtk_printer_is_accepting_jobs (printer))

    g_object_set (cell,

                  "sensitive", FALSE,

                  NULL);

  else

    g_object_set (cell,

                  "sensitive", TRUE,

                  NULL);

}

static void

printer_status_cb (GtkPrintBackend    *backend,

                   GtkPrinter         *printer,

                   GtkPrintUnixDialog *dialog)

{

  GtkPrintUnixDialogPrivate *priv = dialog->priv;

  GtkTreeIter *iter;

  GtkTreeSelection *selection;

  iter = g_object_get_data (G_OBJECT (printer), "gtk-print-tree-iter");

  gtk_list_store_set (GTK_LIST_STORE (priv->printer_list), iter,

                      PRINTER_LIST_COL_ICON, gtk_printer_get_icon_name (printer),

                      PRINTER_LIST_COL_STATE, gtk_printer_get_state_message (printer),

                      PRINTER_LIST_COL_JOBS, gtk_printer_get_job_count (printer),

                      PRINTER_LIST_COL_LOCATION, gtk_printer_get_location (printer),

                      -1);

  /* When the pause state change then we need to update sensitive property

   * of GTK_RESPONSE_OK button inside of selected_printer_changed function. */

  selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (priv->printer_treeview));

  selected_printer_changed (selection, dialog);

  if (gtk_print_backend_printer_list_is_done (backend) &&

      gtk_printer_is_default (printer) &&

      (gtk_tree_selection_count_selected_rows (selection) == 0))

    set_active_printer (dialog, gtk_printer_get_name (printer));

}

static void

printer_added_cb (GtkPrintBackend    *backend,

                  GtkPrinter         *printer,

                  GtkPrintUnixDialog *dialog)

{

  GtkPrintUnixDialogPrivate *priv = dialog->priv;

  GtkTreeIter iter, filter_iter;

  GtkTreeSelection *selection;

  GtkTreePath *path;

  gtk_list_store_append (GTK_LIST_STORE (priv->printer_list), &iter);

  g_object_set_data_full (G_OBJECT (printer),

                         "gtk-print-tree-iter",

                          gtk_tree_iter_copy (&iter),

                          (GDestroyNotify) gtk_tree_iter_free);

  gtk_list_store_set (GTK_LIST_STORE (priv->printer_list), &iter,

                      PRINTER_LIST_COL_ICON, gtk_printer_get_icon_name (printer),

                      PRINTER_LIST_COL_NAME, gtk_printer_get_name (printer),

                      PRINTER_LIST_COL_STATE, gtk_printer_get_state_message (printer),

                      PRINTER_LIST_COL_JOBS, gtk_printer_get_job_count (printer),

                      PRINTER_LIST_COL_LOCATION, gtk_printer_get_location (printer),

                      PRINTER_LIST_COL_PRINTER_OBJ, printer,

                      -1);

  gtk_tree_model_filter_convert_child_iter_to_iter (priv->printer_list_filter,

                                                    &filter_iter, &iter);

  path = gtk_tree_model_get_path (GTK_TREE_MODEL (priv->printer_list_filter), &filter_iter);

  selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (priv->printer_treeview));

  if (priv->waiting_for_printer != NULL &&

      strcmp (gtk_printer_get_name (printer),

              priv->waiting_for_printer) == 0)

    {

      priv->internal_printer_change = TRUE;

      gtk_tree_selection_select_iter (selection, &filter_iter);

      gtk_tree_view_scroll_to_cell (GTK_TREE_VIEW (priv->printer_treeview),

                                    path, NULL, TRUE, 0.5, 0.0);

      priv->internal_printer_change = FALSE;

      g_free (priv->waiting_for_printer);

      priv->waiting_for_printer = NULL;

    }

  else if (is_default_printer (dialog, printer) &&

           gtk_tree_selection_count_selected_rows (selection) == 0)

    {

      priv->internal_printer_change = TRUE;

      gtk_tree_selection_select_iter (selection, &filter_iter);

      gtk_tree_view_scroll_to_cell (GTK_TREE_VIEW (priv->printer_treeview),

                                    path, NULL, TRUE, 0.5, 0.0);

      priv->internal_printer_change = FALSE;

    }

  gtk_tree_path_free (path);

}

static void

printer_list_initialize (GtkPrintUnixDialog *dialog,

                         GtkPrintBackend    *print_backend)

{

  GList *list;

  GList *node;

  g_return_if_fail (print_backend != NULL);

  g_signal_connect_object (print_backend,

                           "printer-added",

                           (GCallback) printer_added_cb,

                           G_OBJECT (dialog), 0);