/* GTK - The GIMP Toolkit

 * gtkprintoperation.c: Print Operation

 * Copyright (C) 2006, Red Hat, Inc.

 *

 * 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 <errno.h>

#include <stdlib.h>       

#include <math.h>

#include <string.h>

#include "gtkprintoperation-private.h"

#include "gtkmarshalers.h"

#include <cairo-pdf.h>

#include "gtkintl.h"

#include "gtkprivate.h"

#include "gtkmessagedialog.h"

#include "gtkalias.h"

#define SHOW_PROGRESS_TIME 1200

#define GTK_PRINT_OPERATION_GET_PRIVATE(obj)(G_TYPE_INSTANCE_GET_PRIVATE ((obj), GTK_TYPE_PRINT_OPERATION, GtkPrintOperationPrivate))

enum 

{

  DONE,

  BEGIN_PRINT,

  PAGINATE,

  REQUEST_PAGE_SETUP,

  DRAW_PAGE,

  END_PRINT,

  STATUS_CHANGED,

  CREATE_CUSTOM_WIDGET,

  CUSTOM_WIDGET_APPLY,

  PREVIEW,

  UPDATE_CUSTOM_WIDGET,

  LAST_SIGNAL

};

enum 

{

  PROP_0,

  PROP_DEFAULT_PAGE_SETUP,

  PROP_PRINT_SETTINGS,

  PROP_JOB_NAME,

  PROP_N_PAGES,

  PROP_CURRENT_PAGE,

  PROP_USE_FULL_PAGE,

  PROP_TRACK_PRINT_STATUS,

  PROP_UNIT,

  PROP_SHOW_PROGRESS,

  PROP_ALLOW_ASYNC,

  PROP_EXPORT_FILENAME,

  PROP_STATUS,

  PROP_STATUS_STRING,

  PROP_CUSTOM_TAB_LABEL,

  PROP_EMBED_PAGE_SETUP,

  PROP_HAS_SELECTION,

  PROP_SUPPORT_SELECTION,

  PROP_N_PAGES_TO_PRINT

};

static guint signals[LAST_SIGNAL] = { 0 };

static int job_nr = 0;

typedef struct _PrintPagesData PrintPagesData;

static void          preview_iface_init      (GtkPrintOperationPreviewIface *iface);

static GtkPageSetup *create_page_setup       (GtkPrintOperation             *op);

static void          common_render_page      (GtkPrintOperation             *op,

					      gint                           page_nr);

static void          increment_page_sequence (PrintPagesData *data);

static void          prepare_data            (PrintPagesData *data);

static void          clamp_page_ranges       (PrintPagesData *data);

G_DEFINE_TYPE_WITH_CODE (GtkPrintOperation, gtk_print_operation, G_TYPE_OBJECT,

			 G_IMPLEMENT_INTERFACE (GTK_TYPE_PRINT_OPERATION_PREVIEW,

						preview_iface_init))

/**

 * gtk_print_error_quark:

 *

 * Registers an error quark for #GtkPrintOperation if necessary.

 * 

 * Return value: The error quark used for #GtkPrintOperation errors.

 *

 * Since: 2.10

 **/

GQuark     

gtk_print_error_quark (void)

{

  static GQuark quark = 0;

  if (quark == 0)

    quark = g_quark_from_static_string ("gtk-print-error-quark");

  return quark;

}

static void

gtk_print_operation_finalize (GObject *object)

{

  GtkPrintOperation *print_operation = GTK_PRINT_OPERATION (object);

  GtkPrintOperationPrivate *priv = print_operation->priv;

  if (priv->free_platform_data &&

      priv->platform_data)

    {

      priv->free_platform_data (priv->platform_data);

      priv->free_platform_data = NULL;

    }

  if (priv->default_page_setup)

    g_object_unref (priv->default_page_setup);

  if (priv->print_settings)

    g_object_unref (priv->print_settings);

  if (priv->print_context)

    g_object_unref (priv->print_context);

  g_free (priv->export_filename);

  g_free (priv->job_name);

  g_free (priv->custom_tab_label);

  g_free (priv->status_string);

  if (priv->print_pages_idle_id > 0)

    g_source_remove (priv->print_pages_idle_id);

  if (priv->show_progress_timeout_id > 0)

    g_source_remove (priv->show_progress_timeout_id);

  if (priv->error)

    g_error_free (priv->error);

  G_OBJECT_CLASS (gtk_print_operation_parent_class)->finalize (object);

}

static void

gtk_print_operation_init (GtkPrintOperation *operation)

{

  GtkPrintOperationPrivate *priv;

  const char *appname;

  priv = operation->priv = GTK_PRINT_OPERATION_GET_PRIVATE (operation);

  priv->status = GTK_PRINT_STATUS_INITIAL;

  priv->status_string = g_strdup ("");

  priv->default_page_setup = NULL;

  priv->print_settings = NULL;

  priv->nr_of_pages = -1;

  priv->nr_of_pages_to_print = -1;

  priv->page_position = -1;

  priv->current_page = -1;

  priv->use_full_page = FALSE;

  priv->show_progress = FALSE;

  priv->export_filename = NULL;

  priv->track_print_status = FALSE;

  priv->is_sync = FALSE;

  priv->support_selection = FALSE;

  priv->has_selection = FALSE;

  priv->embed_page_setup = FALSE;

  priv->page_drawing_state = GTK_PAGE_DRAWING_STATE_READY;

  priv->rloop = NULL;

  priv->unit = GTK_UNIT_PIXEL;

  appname = g_get_application_name ();

  if (appname == NULL)

    appname = "";

  /* translators: this string is the default job title for print

   * jobs. %s gets replaced by the application name, %d gets replaced

   * by the job number.

   */

  priv->job_name = g_strdup_printf (_("%s job #%d"), appname, ++job_nr);

}

static void

preview_iface_render_page (GtkPrintOperationPreview *preview,

			   gint                      page_nr)

{

  GtkPrintOperation *op;

  op = GTK_PRINT_OPERATION (preview);

  common_render_page (op, page_nr);

}

static void

preview_iface_end_preview (GtkPrintOperationPreview *preview)

{

  GtkPrintOperation *op;

  op = GTK_PRINT_OPERATION (preview);

  g_signal_emit (op, signals[END_PRINT], 0, op->priv->print_context);

  if (op->priv->rloop)

    g_main_loop_quit (op->priv->rloop);

  if (op->priv->end_run)

    op->priv->end_run (op, op->priv->is_sync, TRUE);

  _gtk_print_operation_set_status (op, GTK_PRINT_STATUS_FINISHED, NULL);

  g_signal_emit (op, signals[DONE], 0, GTK_PRINT_OPERATION_RESULT_APPLY);

}

static gboolean

preview_iface_is_selected (GtkPrintOperationPreview *preview,

			   gint                      page_nr)

{

  GtkPrintOperation *op;

  GtkPrintOperationPrivate *priv;

  int i;

  op = GTK_PRINT_OPERATION (preview);

  priv = op->priv;

  switch (priv->print_pages)

    {

    case GTK_PRINT_PAGES_SELECTION:

    case GTK_PRINT_PAGES_ALL:

      return (page_nr >= 0) && (page_nr < priv->nr_of_pages);

    case GTK_PRINT_PAGES_CURRENT:

      return page_nr == priv->current_page;

    case GTK_PRINT_PAGES_RANGES:

      for (i = 0; i < priv->num_page_ranges; i++)

	{

	  if (page_nr >= priv->page_ranges[i].start &&

	      (page_nr <= priv->page_ranges[i].end || priv->page_ranges[i].end == -1))

	    return TRUE;

	}

      return FALSE;

    }

  return FALSE;

}

static void

preview_iface_init (GtkPrintOperationPreviewIface *iface)

{

  iface->render_page = preview_iface_render_page;

  iface->end_preview = preview_iface_end_preview;

  iface->is_selected = preview_iface_is_selected;

}

static void

preview_start_page (GtkPrintOperation *op,

		    GtkPrintContext   *print_context,

		    GtkPageSetup      *page_setup)

{

  if ((op->priv->manual_number_up < 2) ||

      (op->priv->page_position % op->priv->manual_number_up == 0))

    g_signal_emit_by_name (op, "got-page-size", print_context, page_setup);

}

static void

preview_end_page (GtkPrintOperation *op,

		  GtkPrintContext   *print_context)

{

  cairo_t *cr;

  cr = gtk_print_context_get_cairo_context (print_context);

  if ((op->priv->manual_number_up < 2) ||

      ((op->priv->page_position + 1) % op->priv->manual_number_up == 0) ||

      (op->priv->page_position == op->priv->nr_of_pages_to_print - 1))

    cairo_show_page (cr);

}

static void

preview_end_run (GtkPrintOperation *op,

		 gboolean           wait,

		 gboolean           cancelled)

{

  g_free (op->priv->page_ranges);

  op->priv->page_ranges = NULL;

}

static void

gtk_print_operation_set_property (GObject      *object,

				  guint         prop_id,

				  const GValue *value,

				  GParamSpec   *pspec)

{

  GtkPrintOperation *op = GTK_PRINT_OPERATION (object);

  switch (prop_id)

    {

    case PROP_DEFAULT_PAGE_SETUP:

      gtk_print_operation_set_default_page_setup (op, g_value_get_object (value));

      break;

    case PROP_PRINT_SETTINGS:

      gtk_print_operation_set_print_settings (op, g_value_get_object (value));

      break;

    case PROP_JOB_NAME:

      gtk_print_operation_set_job_name (op, g_value_get_string (value));

      break;

    case PROP_N_PAGES:

      gtk_print_operation_set_n_pages (op, g_value_get_int (value));

      break;

    case PROP_CURRENT_PAGE:

      gtk_print_operation_set_current_page (op, g_value_get_int (value));

      break;

    case PROP_USE_FULL_PAGE:

      gtk_print_operation_set_use_full_page (op, g_value_get_boolean (value));

      break;

    case PROP_TRACK_PRINT_STATUS:

      gtk_print_operation_set_track_print_status (op, g_value_get_boolean (value));

      break;

    case PROP_UNIT:

      gtk_print_operation_set_unit (op, g_value_get_enum (value));

      break;

    case PROP_ALLOW_ASYNC:

      gtk_print_operation_set_allow_async (op, g_value_get_boolean (value));

      break;

    case PROP_SHOW_PROGRESS:

      gtk_print_operation_set_show_progress (op, g_value_get_boolean (value));

      break;

    case PROP_EXPORT_FILENAME:

      gtk_print_operation_set_export_filename (op, g_value_get_string (value));

      break;

    case PROP_CUSTOM_TAB_LABEL:

      gtk_print_operation_set_custom_tab_label (op, g_value_get_string (value));

      break;

    case PROP_EMBED_PAGE_SETUP:

      gtk_print_operation_set_embed_page_setup (op, g_value_get_boolean (value));

      break;

    case PROP_HAS_SELECTION:

      gtk_print_operation_set_has_selection (op, g_value_get_boolean (value));

      break;

    case PROP_SUPPORT_SELECTION:

      gtk_print_operation_set_support_selection (op, g_value_get_boolean (value));

      break;

    default:

      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);

      break;

    }

}

static void

gtk_print_operation_get_property (GObject    *object,

				  guint       prop_id,

				  GValue     *value,

				  GParamSpec *pspec)

{

  GtkPrintOperation *op = GTK_PRINT_OPERATION (object);

  GtkPrintOperationPrivate *priv = op->priv;

  switch (prop_id)

    {

    case PROP_DEFAULT_PAGE_SETUP:

      g_value_set_object (value, priv->default_page_setup);

      break;

    case PROP_PRINT_SETTINGS:

      g_value_set_object (value, priv->print_settings);

      break;

    case PROP_JOB_NAME:

      g_value_set_string (value, priv->job_name);

      break;

    case PROP_N_PAGES:

      g_value_set_int (value, priv->nr_of_pages);

      break;

    case PROP_CURRENT_PAGE:

      g_value_set_int (value, priv->current_page);

      break;      

    case PROP_USE_FULL_PAGE:

      g_value_set_boolean (value, priv->use_full_page);

      break;

    case PROP_TRACK_PRINT_STATUS:

      g_value_set_boolean (value, priv->track_print_status);

      break;

    case PROP_UNIT:

      g_value_set_enum (value, priv->unit);

      break;

    case PROP_ALLOW_ASYNC:

      g_value_set_boolean (value, priv->allow_async);

      break;

    case PROP_SHOW_PROGRESS:

      g_value_set_boolean (value, priv->show_progress);

      break;

    case PROP_EXPORT_FILENAME:

      g_value_set_string (value, priv->export_filename);

      break;

    case PROP_STATUS:

      g_value_set_enum (value, priv->status);

      break;

    case PROP_STATUS_STRING:

      g_value_set_string (value, priv->status_string);

      break;

    case PROP_CUSTOM_TAB_LABEL:

      g_value_set_string (value, priv->custom_tab_label);

      break;

    case PROP_EMBED_PAGE_SETUP:

      g_value_set_boolean (value, priv->embed_page_setup);

      break;

    case PROP_HAS_SELECTION:

      g_value_set_boolean (value, priv->has_selection);

      break;

    case PROP_SUPPORT_SELECTION:

      g_value_set_boolean (value, priv->support_selection);

      break;

    case PROP_N_PAGES_TO_PRINT:

      g_value_set_int (value, priv->nr_of_pages_to_print);

      break;

    default:

      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);

      break;

    }

}

struct _PrintPagesData

{

  GtkPrintOperation *op;

  gint uncollated_copies;

  gint collated_copies;

  gint uncollated, collated, total;

  gint range, num_ranges;

  GtkPageRange *ranges;

  GtkPageRange one_range;

  gint page;

  gint sheet;

  gint first_position, last_position;

  gint first_sheet;

  gint num_of_sheets;

  gint *pages;

  GtkWidget *progress;

  gboolean initialized;

  gboolean is_preview;

  gboolean done;

};

typedef struct

{

  GtkPrintOperationPreview *preview;

  GtkPrintContext *print_context;

  GtkWindow *parent;

  cairo_surface_t *surface;

  gchar *filename;

  gboolean wait;

  PrintPagesData *pages_data;

} PreviewOp;

static void

preview_print_idle_done (gpointer data)

{

  GtkPrintOperation *op;

  PreviewOp *pop = (PreviewOp *) data;

  op = GTK_PRINT_OPERATION (pop->preview);

  cairo_surface_finish (pop->surface);

  /* Surface is destroyed in launch_preview */

  _gtk_print_operation_platform_backend_launch_preview (op,

							pop->surface,

							pop->parent,

							pop->filename);

  g_free (pop->filename);

  gtk_print_operation_preview_end_preview (pop->preview);

  g_object_unref (pop->pages_data->op);

  g_free (pop->pages_data->pages);

  g_free (pop->pages_data);

  g_object_unref (op);

  g_free (pop);

}

static gboolean

preview_print_idle (gpointer data)

{

  PreviewOp *pop;

  GtkPrintOperation *op;

  GtkPrintOperationPrivate *priv; 

  gboolean done = FALSE;

  pop = (PreviewOp *) data;

  op = GTK_PRINT_OPERATION (pop->preview);

  priv = op->priv;

  if (priv->page_drawing_state == GTK_PAGE_DRAWING_STATE_READY)

    {

      if (!pop->pages_data->initialized)

        {

          pop->pages_data->initialized = TRUE;

          prepare_data (pop->pages_data);

        }

      else

        {

          increment_page_sequence (pop->pages_data);

          if (!pop->pages_data->done)

            gtk_print_operation_preview_render_page (pop->preview, pop->pages_data->page);

          else

            done = priv->page_drawing_state == GTK_PAGE_DRAWING_STATE_READY;

        }

    }

  return !done;

}

static void

preview_got_page_size (GtkPrintOperationPreview *preview, 

		       GtkPrintContext          *context,

		       GtkPageSetup             *page_setup,

		       PreviewOp                *pop)

{

  GtkPrintOperation *op = GTK_PRINT_OPERATION (preview);

  cairo_t *cr;

  _gtk_print_operation_platform_backend_resize_preview_surface (op, page_setup, pop->surface);

  cr = gtk_print_context_get_cairo_context (pop->print_context);

  _gtk_print_operation_platform_backend_preview_start_page (op, pop->surface, cr);

}

static void

preview_ready (GtkPrintOperationPreview *preview,

               GtkPrintContext          *context,

	       PreviewOp                *pop)

{

  pop->print_context = context;

  g_object_ref (preview);

  gdk_threads_add_idle_full (G_PRIORITY_DEFAULT_IDLE + 10,

	                     preview_print_idle,

		             pop,

		             preview_print_idle_done);

}

static gboolean

gtk_print_operation_preview_handler (GtkPrintOperation        *op,

                                     GtkPrintOperationPreview *preview, 

				     GtkPrintContext          *context,

				     GtkWindow                *parent)

{

  gdouble dpi_x, dpi_y;

  PreviewOp *pop;

  GtkPageSetup *page_setup;

  cairo_t *cr;

  pop = g_new0 (PreviewOp, 1);

  pop->filename = NULL;

  pop->preview = preview;

  pop->parent = parent;

  pop->pages_data = g_new0 (PrintPagesData, 1);

  pop->pages_data->op = g_object_ref (GTK_PRINT_OPERATION (preview));

  pop->pages_data->is_preview = TRUE;

  page_setup = gtk_print_context_get_page_setup (context);

  pop->surface =

    _gtk_print_operation_platform_backend_create_preview_surface (op,

								  page_setup,

								  &dpi_x, &dpi_y,

								  &pop->filename);

  if (pop->surface == NULL)

    {

      g_free (pop);

      return FALSE;

    }

  cr = cairo_create (pop->surface);

  gtk_print_context_set_cairo_context (op->priv->print_context, cr,

				       dpi_x, dpi_y);

  cairo_destroy (cr);

  g_signal_connect (preview, "ready", (GCallback) preview_ready, pop);

  g_signal_connect (preview, "got-page-size", (GCallback) preview_got_page_size, pop);

  return TRUE;

}

static GtkWidget *

gtk_print_operation_create_custom_widget (GtkPrintOperation *operation)

{

  return NULL;

}

static gboolean

gtk_print_operation_paginate (GtkPrintOperation *operation,

                              GtkPrintContext   *context)

{

  /* assume the number of pages is already set and pagination is not needed */

  return TRUE;

}

static void

gtk_print_operation_done (GtkPrintOperation       *operation,

                          GtkPrintOperationResult  result)

{

  GtkPrintOperationPrivate *priv = operation->priv;

  if (priv->print_context)

    {

      g_object_unref (priv->print_context);

      priv->print_context = NULL;

    } 

}

static gboolean

custom_widget_accumulator (GSignalInvocationHint *ihint,

			   GValue                *return_accu,

			   const GValue          *handler_return,

			   gpointer               dummy)

{

  gboolean continue_emission;

  GtkWidget *widget;

  widget = g_value_get_object (handler_return);

  if (widget != NULL)

    g_value_set_object (return_accu, widget);

  continue_emission = (widget == NULL);

  return continue_emission;

}

static gboolean

paginate_accumulator (GSignalInvocationHint *ihint,

                      GValue                *return_accu,

                      const GValue          *handler_return,

                      gpointer               dummy)

{

  *return_accu = *handler_return;

  /* Stop signal emission on first invocation, so if it's a callback then

   * the default handler won't run. */

  return FALSE;

}

static void

gtk_print_operation_class_init (GtkPrintOperationClass *class)

{

  GObjectClass *gobject_class = (GObjectClass *)class;

  gobject_class->set_property = gtk_print_operation_set_property;

  gobject_class->get_property = gtk_print_operation_get_property;

  gobject_class->finalize = gtk_print_operation_finalize;

  class->preview = gtk_print_operation_preview_handler; 

  class->create_custom_widget = gtk_print_operation_create_custom_widget;

  class->paginate = gtk_print_operation_paginate;

  class->done = gtk_print_operation_done;

  g_type_class_add_private (gobject_class, sizeof (GtkPrintOperationPrivate));

  /**

   * GtkPrintOperation::done:

   * @operation: the #GtkPrintOperation on which the signal was emitted

   * @result: the result of the print operation

   *

   * Emitted when the print operation run has finished doing

   * everything required for printing. 

   *

   * @result gives you information about what happened during the run. 

   * If @result is %GTK_PRINT_OPERATION_RESULT_ERROR then you can call

   * gtk_print_operation_get_error() for more information.

   *

   * If you enabled print status tracking then 

   * gtk_print_operation_is_finished() may still return %FALSE 

   * after #GtkPrintOperation::done was emitted.

   *

   * Since: 2.10

   */

  signals[DONE] =

    g_signal_new (I_("done"),

		  G_TYPE_FROM_CLASS (gobject_class),

		  G_SIGNAL_RUN_LAST,

		  G_STRUCT_OFFSET (GtkPrintOperationClass, done),

		  NULL, NULL,

		  g_cclosure_marshal_VOID__ENUM,

		  G_TYPE_NONE, 1, GTK_TYPE_PRINT_OPERATION_RESULT);

  /**

   * GtkPrintOperation::begin-print:

   * @operation: the #GtkPrintOperation on which the signal was emitted

   * @context: the #GtkPrintContext for the current operation

   *

   * Emitted after the user has finished changing print settings

   * in the dialog, before the actual rendering starts. 

   *

   * A typical use for ::begin-print is to use the parameters from the

   * #GtkPrintContext and paginate the document accordingly, and then

   * set the number of pages with gtk_print_operation_set_n_pages().

   *

   * Since: 2.10

   */

  signals[BEGIN_PRINT] =

    g_signal_new (I_("begin-print"),

		  G_TYPE_FROM_CLASS (gobject_class),

		  G_SIGNAL_RUN_LAST,

		  G_STRUCT_OFFSET (GtkPrintOperationClass, begin_print),

		  NULL, NULL,

		  g_cclosure_marshal_VOID__OBJECT,

		  G_TYPE_NONE, 1, GTK_TYPE_PRINT_CONTEXT);

   /**

   * GtkPrintOperation::paginate:

   * @operation: the #GtkPrintOperation on which the signal was emitted

   * @context: the #GtkPrintContext for the current operation

   *

   * Emitted after the #GtkPrintOperation::begin-print signal, but before 

   * the actual rendering starts. It keeps getting emitted until a connected 

   * signal handler returns %TRUE.

   *

   * The ::paginate signal is intended to be used for paginating a document

   * in small chunks, to avoid blocking the user interface for a long

   * time. The signal handler should update the number of pages using

   * gtk_print_operation_set_n_pages(), and return %TRUE if the document

   * has been completely paginated.

   *

   * If you don't need to do pagination in chunks, you can simply do

   * it all in the ::begin-print handler, and set the number of pages

   * from there.

   *

   * Return value: %TRUE if pagination is complete

   *

   * Since: 2.10

   */

  signals[PAGINATE] =

    g_signal_new (I_("paginate"),

		  G_TYPE_FROM_CLASS (gobject_class),

		  G_SIGNAL_RUN_LAST,

		  G_STRUCT_OFFSET (GtkPrintOperationClass, paginate),

		  paginate_accumulator, NULL,

		  _gtk_marshal_BOOLEAN__OBJECT,

		  G_TYPE_BOOLEAN, 1, GTK_TYPE_PRINT_CONTEXT);

  /**

   * GtkPrintOperation::request-page-setup:

   * @operation: the #GtkPrintOperation on which the signal was emitted

   * @context: the #GtkPrintContext for the current operation

   * @page_nr: the number of the currently printed page (0-based)

   * @setup: the #GtkPageSetup 

   * 

   * Emitted once for every page that is printed, to give

   * the application a chance to modify the page setup. Any changes 

   * done to @setup will be in force only for printing this page.

   *

   * Since: 2.10

   */

  signals[REQUEST_PAGE_SETUP] =

    g_signal_new (I_("request-page-setup"),

		  G_TYPE_FROM_CLASS (gobject_class),

		  G_SIGNAL_RUN_LAST,

		  G_STRUCT_OFFSET (GtkPrintOperationClass, request_page_setup),

		  NULL, NULL,

		  _gtk_marshal_VOID__OBJECT_INT_OBJECT,

		  G_TYPE_NONE, 3,

		  GTK_TYPE_PRINT_CONTEXT,

		  G_TYPE_INT,

		  GTK_TYPE_PAGE_SETUP);

  /**

   * GtkPrintOperation::draw-page:

   * @operation: the #GtkPrintOperation on which the signal was emitted

   * @context: the #GtkPrintContext for the current operation

   * @page_nr: the number of the currently printed page (0-based)

   *

   * Emitted for every page that is printed. The signal handler

   * must render the @page_nr's page onto the cairo context obtained

   * from @context using gtk_print_context_get_cairo_context().

   * |[

   * static void

   * draw_page (GtkPrintOperation *operation,

   *            GtkPrintContext   *context,

   *            gint               page_nr,

   *            gpointer           user_data)

   * {

   *   cairo_t *cr;

   *   PangoLayout *layout;

   *   gdouble width, text_height;

   *   gint layout_height;

   *   PangoFontDescription *desc;

   *   

   *   cr = gtk_print_context_get_cairo_context (context);

   *   width = gtk_print_context_get_width (context);

   *   

   *   cairo_rectangle (cr, 0, 0, width, HEADER_HEIGHT);

   *   

   *   cairo_set_source_rgb (cr, 0.8, 0.8, 0.8);

   *   cairo_fill (cr);

   *   

   *   layout = gtk_print_context_create_pango_layout (context);

   *   

   *   desc = pango_font_description_from_string ("sans 14");

   *   pango_layout_set_font_description (layout, desc);

   *   pango_font_description_free (desc);

   *   

   *   pango_layout_set_text (layout, "some text", -1);

   *   pango_layout_set_width (layout, width * PANGO_SCALE);

   *   pango_layout_set_alignment (layout, PANGO_ALIGN_CENTER);

   *      		      

   *   pango_layout_get_size (layout, NULL, &layout_height);

   *   text_height = (gdouble)layout_height / PANGO_SCALE;

   *   

   *   cairo_move_to (cr, width / 2,  (HEADER_HEIGHT - text_height) / 2);

   *   pango_cairo_show_layout (cr, layout);

   *   

   *   g_object_unref (layout);

   * }

   * ]|

   *

   * Use gtk_print_operation_set_use_full_page() and 

   * gtk_print_operation_set_unit() before starting the print operation

   * to set up the transformation of the cairo context according to your

   * needs.

   * 

   * Since: 2.10

   */

  signals[DRAW_PAGE] =

    g_signal_new (I_("draw-page"),

		  G_TYPE_FROM_CLASS (gobject_class),

		  G_SIGNAL_RUN_LAST,

		  G_STRUCT_OFFSET (GtkPrintOperationClass, draw_page),

		  NULL, NULL,

		  _gtk_marshal_VOID__OBJECT_INT,

		  G_TYPE_NONE, 2,

		  GTK_TYPE_PRINT_CONTEXT,

		  G_TYPE_INT);

  /**

   * GtkPrintOperation::end-print:

   * @operation: the #GtkPrintOperation on which the signal was emitted

   * @context: the #GtkPrintContext for the current operation

   *

   * Emitted after all pages have been rendered. 

   * A handler for this signal can clean up any resources that have

   * been allocated in the #GtkPrintOperation::begin-print handler.

   * 

   * Since: 2.10

   */

  signals[END_PRINT] =

    g_signal_new (I_("end-print"),

		  G_TYPE_FROM_CLASS (gobject_class),

		  G_SIGNAL_RUN_LAST,

		  G_STRUCT_OFFSET (GtkPrintOperationClass, end_print),

		  NULL, NULL,

		  g_cclosure_marshal_VOID__OBJECT,

		  G_TYPE_NONE, 1, GTK_TYPE_PRINT_CONTEXT);

  /**

   * GtkPrintOperation::status-changed:

   * @operation: the #GtkPrintOperation on which the signal was emitted

   *

   * Emitted at between the various phases of the print operation.

   * See #GtkPrintStatus for the phases that are being discriminated.

   * Use gtk_print_operation_get_status() to find out the current

   * status.

   *

   * Since: 2.10

   */