Pileus Git - ~andy/gtk/blob - gtk/gtkprintoperation-unix.c

   1 /* GTK - The GIMP Toolkit
   2  * gtkprintoperation-unix.c: Print Operation Details for Unix
   3  *                           and Unix-like platforms
   4  * Copyright (C) 2006, Red Hat, Inc.
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, write to the
  18  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  19  * Boston, MA 02111-1307, USA.
  20  */
  21
  22 #include "config.h"
  23 #ifdef HAVE_UNISTD_H
  24 #include <unistd.h>
  25 #endif
  26 #include <sys/types.h>
  27 #include <sys/stat.h>
  28 #include <string.h>
  29 #include <errno.h>
  30 #include <stdlib.h>
  31 #include <fcntl.h>
  32
  33 #include <glib/gstdio.h>
  34 #include "gtkprintoperation-private.h"
  35 #include "gtkmessagedialog.h"
  36
  37 #include <cairo-pdf.h>
  38 #include <cairo-ps.h>
  39 #include "gtkprivate.h"
  40 #include "gtkprintunixdialog.h"
  41 #include "gtkpagesetupunixdialog.h"
  42 #include "gtkprintbackend.h"
  43 #include "gtkprinter.h"
  44 #include "gtkprintjob.h"
  45 #include "gtklabel.h"
  46 #include "gtkintl.h"
  47
  48
  49 typedef struct
  50 {
  51   GtkWindow *parent;        /* just in case we need to throw error dialogs */
  52   GMainLoop *loop;
  53   gboolean data_sent;
  54
  55   /* Real printing (not preview) */
  56   GtkPrintJob *job;         /* the job we are sending to the printer */
  57   cairo_surface_t *surface;
  58   gulong job_status_changed_tag;
  59
  60
  61 } GtkPrintOperationUnix;
  62
  63 typedef struct _PrinterFinder PrinterFinder;
  64
  65 static void printer_finder_free (PrinterFinder *finder);
  66 static void find_printer        (const gchar   *printer,
  67                                  GFunc          func,
  68                                  gpointer       data);
  69
  70 static void
  71 unix_start_page (GtkPrintOperation *op,
  72                  GtkPrintContext   *print_context,
  73                  GtkPageSetup      *page_setup)
  74 {
  75   GtkPrintOperationUnix *op_unix;
  76   GtkPaperSize *paper_size;
  77   cairo_surface_type_t type;
  78   gdouble w, h;
  79
  80   op_unix = op->priv->platform_data;
  81
  82   paper_size = gtk_page_setup_get_paper_size (page_setup);
  83
  84   w = gtk_paper_size_get_width (paper_size, GTK_UNIT_POINTS);
  85   h = gtk_paper_size_get_height (paper_size, GTK_UNIT_POINTS);
  86
  87   type = cairo_surface_get_type (op_unix->surface);
  88
  89   if ((op->priv->manual_number_up < 2) ||
  90       (op->priv->page_position % op->priv->manual_number_up == 0))
  91     {
  92       if (type == CAIRO_SURFACE_TYPE_PS)
  93         {
  94           cairo_ps_surface_set_size (op_unix->surface, w, h);
  95           cairo_ps_surface_dsc_begin_page_setup (op_unix->surface);
  96           switch (gtk_page_setup_get_orientation (page_setup))
  97             {
  98               case GTK_PAGE_ORIENTATION_PORTRAIT:
  99               case GTK_PAGE_ORIENTATION_REVERSE_PORTRAIT:
 100                 cairo_ps_surface_dsc_comment (op_unix->surface, "%%PageOrientation: Portrait");
 101                 break;
 102
 103               case GTK_PAGE_ORIENTATION_LANDSCAPE:
 104               case GTK_PAGE_ORIENTATION_REVERSE_LANDSCAPE:
 105                 cairo_ps_surface_dsc_comment (op_unix->surface, "%%PageOrientation: Landscape");
 106                 break;
 107             }
 108          }
 109       else if (type == CAIRO_SURFACE_TYPE_PDF)
 110         {
 111           cairo_pdf_surface_set_size (op_unix->surface, w, h);
 112         }
 113     }
 114 }
 115
 116 static void
 117 unix_end_page (GtkPrintOperation *op,
 118                GtkPrintContext   *print_context)
 119 {
 120   cairo_t *cr;
 121
 122   cr = gtk_print_context_get_cairo_context (print_context);
 123
 124   if ((op->priv->manual_number_up < 2) ||
 125       ((op->priv->page_position + 1) % op->priv->manual_number_up == 0) ||
 126       (op->priv->page_position == op->priv->nr_of_pages_to_print - 1))
 127     cairo_show_page (cr);
 128 }
 129
 130 static void
 131 op_unix_free (GtkPrintOperationUnix *op_unix)
 132 {
 133   if (op_unix->job)
 134     {
 135       g_signal_handler_disconnect (op_unix->job,
 136                                    op_unix->job_status_changed_tag);
 137       g_object_unref (op_unix->job);
 138     }
 139
 140   g_free (op_unix);
 141 }
 142
 143 static gchar *
 144 shell_command_substitute_file (const gchar *cmd,
 145                                const gchar *pdf_filename,
 146                                const gchar *settings_filename,
 147                                gboolean    *pdf_filename_replaced,
 148                                gboolean    *settings_filename_replaced)
 149 {
 150   const gchar *inptr, *start;
 151   GString *final;
 152
 153   g_return_val_if_fail (cmd != NULL, NULL);
 154   g_return_val_if_fail (pdf_filename != NULL, NULL);
 155   g_return_val_if_fail (settings_filename != NULL, NULL);
 156
 157   final = g_string_new (NULL);
 158
 159   *pdf_filename_replaced = FALSE;
 160   *settings_filename_replaced = FALSE;
 161
 162   start = inptr = cmd;
 163   while ((inptr = strchr (inptr, '%')) != NULL)
 164     {
 165       g_string_append_len (final, start, inptr - start);
 166       inptr++;
 167       switch (*inptr)
 168         {
 169           case 'f':
 170             g_string_append (final, pdf_filename);
 171             *pdf_filename_replaced = TRUE;
 172             break;
 173
 174           case 's':
 175             g_string_append (final, settings_filename);
 176             *settings_filename_replaced = TRUE;
 177             break;
 178
 179           case '%':
 180             g_string_append_c (final, '%');
 181             break;
 182
 183           default:
 184             g_string_append_c (final, '%');
 185             if (*inptr)
 186               g_string_append_c (final, *inptr);
 187             break;
 188         }
 189       if (*inptr)
 190         inptr++;
 191       start = inptr;
 192     }
 193   g_string_append (final, start);
 194
 195   return g_string_free (final, FALSE);
 196 }
 197
 198 void
 199 _gtk_print_operation_platform_backend_launch_preview (GtkPrintOperation *op,
 200                                                       cairo_surface_t   *surface,
 201                                                       GtkWindow         *parent,
 202                                                       const gchar       *filename)
 203 {
 204   GAppInfo *appinfo;
 205   GdkAppLaunchContext *context;
 206   gchar *cmd;
 207   gchar *preview_cmd;
 208   GtkSettings *settings;
 209   GtkPrintSettings *print_settings = NULL;
 210   GtkPageSetup *page_setup;
 211   GKeyFile *key_file = NULL;
 212   gchar *data = NULL;
 213   gsize data_len;
 214   gchar *settings_filename = NULL;
 215   gchar *quoted_filename;
 216   gchar *quoted_settings_filename;
 217   gboolean filename_used = FALSE;
 218   gboolean settings_used = FALSE;
 219   GdkScreen *screen;
 220   GError *error = NULL;
 221   gint fd;
 222   gboolean retval;
 223
 224   cairo_surface_destroy (surface);
 225
 226   if (parent)
 227     screen = gtk_window_get_screen (parent);
 228   else
 229     screen = gdk_screen_get_default ();
 230
 231   fd = g_file_open_tmp ("settingsXXXXXX.ini", &settings_filename, &error);
 232   if (fd < 0)
 233     goto out;
 234
 235   key_file = g_key_file_new ();
 236
 237   print_settings = gtk_print_settings_copy (gtk_print_operation_get_print_settings (op));
 238
 239   if (print_settings != NULL)
 240     {
 241       gtk_print_settings_set_reverse (print_settings, FALSE);
 242       gtk_print_settings_set_page_set (print_settings, GTK_PAGE_SET_ALL);
 243       gtk_print_settings_set_scale (print_settings, 1.0);
 244       gtk_print_settings_set_number_up (print_settings, 1);
 245       gtk_print_settings_set_number_up_layout (print_settings, GTK_NUMBER_UP_LAYOUT_LEFT_TO_RIGHT_TOP_TO_BOTTOM);
 246
 247       /*  These removals are neccessary because cups-* settings have higher priority
 248        *  than normal settings.
 249        */
 250       gtk_print_settings_unset (print_settings, "cups-reverse");
 251       gtk_print_settings_unset (print_settings, "cups-page-set");
 252       gtk_print_settings_unset (print_settings, "cups-scale");
 253       gtk_print_settings_unset (print_settings, "cups-number-up");
 254       gtk_print_settings_unset (print_settings, "cups-number-up-layout");
 255
 256       gtk_print_settings_to_key_file (print_settings, key_file, NULL);
 257       g_object_unref (print_settings);
 258     }
 259
 260   page_setup = gtk_print_context_get_page_setup (op->priv->print_context);
 261   gtk_page_setup_to_key_file (page_setup, key_file, NULL);
 262
 263   g_key_file_set_string (key_file, "Print Job", "title", op->priv->job_name);
 264
 265   data = g_key_file_to_data (key_file, &data_len, &error);
 266   if (!data)
 267     goto out;
 268
 269   retval = g_file_set_contents (settings_filename, data, data_len, &error);
 270   if (!retval)
 271     goto out;
 272
 273   settings = gtk_settings_get_for_screen (screen);
 274   g_object_get (settings, "gtk-print-preview-command", &preview_cmd, NULL);
 275
 276   quoted_filename = g_shell_quote (filename);
 277   quoted_settings_filename = g_shell_quote (settings_filename);
 278   cmd = shell_command_substitute_file (preview_cmd, quoted_filename, quoted_settings_filename, &filename_used, &settings_used);
 279
 280   appinfo = g_app_info_create_from_commandline (cmd,
 281                                                 "Print Preview",
 282                                                 G_APP_INFO_CREATE_NONE,
 283                                                 &error);
 284
 285   g_free (preview_cmd);
 286   g_free (quoted_filename);
 287   g_free (quoted_settings_filename);
 288   g_free (cmd);
 289
 290   if (error != NULL)
 291     goto out;
 292
 293   context = gdk_display_get_app_launch_context (gdk_screen_get_display (screen));
 294   gdk_app_launch_context_set_screen (context, screen);
 295   g_app_info_launch (appinfo, NULL, G_APP_LAUNCH_CONTEXT (context), &error);
 296
 297   g_object_unref (context);
 298   g_object_unref (appinfo);
 299
 300   if (error != NULL)
 301     {
 302       gchar* uri;
 303
 304       g_warning ("%s %s", _("Error launching preview"), error->message);
 305
 306       g_error_free (error);
 307       error = NULL;
 308       uri = g_filename_to_uri (filename, NULL, NULL);
 309       gtk_show_uri (screen, uri, GDK_CURRENT_TIME, &error);
 310       g_free (uri);
 311     }
 312
 313  out:
 314   if (error != NULL)
 315     {
 316       if (op->priv->error == NULL)
 317         op->priv->error = error;
 318       else
 319         g_error_free (error);
 320
 321       filename_used = FALSE;
 322       settings_used = FALSE;
 323    }
 324
 325   if (!filename_used)
 326     g_unlink (filename);
 327
 328   if (!settings_used)
 329     g_unlink (settings_filename);
 330
 331   if (fd > 0)
 332     close (fd);
 333
 334   if (key_file)
 335     g_key_file_free (key_file);
 336   g_free (data);
 337   g_free (settings_filename);
 338 }
 339
 340 static void
 341 unix_finish_send  (GtkPrintJob  *job,
 342                    gpointer      user_data,
 343                    const GError *error)
 344 {
 345   GtkPrintOperation *op = (GtkPrintOperation *) user_data;
 346   GtkPrintOperationUnix *op_unix = op->priv->platform_data;
 347
 348   if (error != NULL && op->priv->error == NULL)
 349     op->priv->error = g_error_copy (error);
 350
 351   op_unix->data_sent = TRUE;
 352
 353   if (op_unix->loop)
 354     g_main_loop_quit (op_unix->loop);
 355
 356   g_object_unref (op);
 357 }
 358
 359 static void
 360 unix_end_run (GtkPrintOperation *op,
 361               gboolean           wait,
 362               gboolean           cancelled)
 363 {
 364   GtkPrintOperationUnix *op_unix = op->priv->platform_data;
 365
 366   cairo_surface_finish (op_unix->surface);
 367
 368   if (cancelled)
 369     return;
 370
 371   if (wait)
 372     op_unix->loop = g_main_loop_new (NULL, FALSE);
 373
 374   /* TODO: Check for error */
 375   if (op_unix->job != NULL)
 376     {
 377       g_object_ref (op);
 378       gtk_print_job_send (op_unix->job,
 379                           unix_finish_send,
 380                           op, NULL);
 381     }
 382
 383   if (wait)
 384     {
 385       g_object_ref (op);
 386       if (!op_unix->data_sent)
 387         {
 388           GDK_THREADS_LEAVE ();
 389           g_main_loop_run (op_unix->loop);
 390           GDK_THREADS_ENTER ();
 391         }
 392       g_main_loop_unref (op_unix->loop);
 393       op_unix->loop = NULL;
 394       g_object_unref (op);
 395     }
 396 }
 397
 398 static void
 399 job_status_changed_cb (GtkPrintJob       *job,
 400                        GtkPrintOperation *op)
 401 {
 402   _gtk_print_operation_set_status (op, gtk_print_job_get_status (job), NULL);
 403 }
 404
 405
 406 static void
 407 print_setup_changed_cb (GtkPrintUnixDialog *print_dialog,
 408                         GParamSpec         *pspec,
 409                         gpointer            user_data)
 410 {
 411   GtkPageSetup             *page_setup;
 412   GtkPrintSettings         *print_settings;
 413   GtkPrintOperation        *op = user_data;
 414   GtkPrintOperationPrivate *priv = op->priv;
 415
 416   page_setup = gtk_print_unix_dialog_get_page_setup (print_dialog);
 417   print_settings = gtk_print_unix_dialog_get_settings (print_dialog);
 418
 419   g_signal_emit_by_name (op,
 420                          "update-custom-widget",
 421                          priv->custom_widget,
 422                          page_setup,
 423                          print_settings);
 424 }
 425
 426 static GtkWidget *
 427 get_print_dialog (GtkPrintOperation *op,
 428                   GtkWindow         *parent)
 429 {
 430   GtkPrintOperationPrivate *priv = op->priv;
 431   GtkWidget *pd, *label;
 432   const gchar *custom_tab_label;
 433
 434   pd = gtk_print_unix_dialog_new (NULL, parent);
 435
 436   gtk_print_unix_dialog_set_manual_capabilities (GTK_PRINT_UNIX_DIALOG (pd),
 437                                                  GTK_PRINT_CAPABILITY_PAGE_SET |
 438                                                  GTK_PRINT_CAPABILITY_COPIES |
 439                                                  GTK_PRINT_CAPABILITY_COLLATE |
 440                                                  GTK_PRINT_CAPABILITY_REVERSE |
 441                                                  GTK_PRINT_CAPABILITY_SCALE |
 442                                                  GTK_PRINT_CAPABILITY_PREVIEW |
 443                                                  GTK_PRINT_CAPABILITY_NUMBER_UP |
 444                                                  GTK_PRINT_CAPABILITY_NUMBER_UP_LAYOUT);
 445
 446   if (priv->print_settings)
 447     gtk_print_unix_dialog_set_settings (GTK_PRINT_UNIX_DIALOG (pd),
 448                                         priv->print_settings);
 449
 450   if (priv->default_page_setup)
 451     gtk_print_unix_dialog_set_page_setup (GTK_PRINT_UNIX_DIALOG (pd),
 452                                           priv->default_page_setup);
 453
 454   gtk_print_unix_dialog_set_embed_page_setup (GTK_PRINT_UNIX_DIALOG (pd),
 455                                               priv->embed_page_setup);
 456
 457   gtk_print_unix_dialog_set_current_page (GTK_PRINT_UNIX_DIALOG (pd),
 458                                           priv->current_page);
 459
 460   gtk_print_unix_dialog_set_support_selection (GTK_PRINT_UNIX_DIALOG (pd),
 461                                                priv->support_selection);
 462
 463   gtk_print_unix_dialog_set_has_selection (GTK_PRINT_UNIX_DIALOG (pd),
 464                                            priv->has_selection);
 465
 466   g_signal_emit_by_name (op, "create-custom-widget",
 467                          &priv->custom_widget);
 468
 469   if (priv->custom_widget)
 470     {
 471       custom_tab_label = priv->custom_tab_label;
 472
 473       if (custom_tab_label == NULL)
 474         {
 475           custom_tab_label = g_get_application_name ();
 476           if (custom_tab_label == NULL)
 477             custom_tab_label = _("Application");
 478         }
 479
 480       label = gtk_label_new (custom_tab_label);
 481
 482       gtk_print_unix_dialog_add_custom_tab (GTK_PRINT_UNIX_DIALOG (pd),
 483                                             priv->custom_widget, label);
 484
 485       g_signal_connect (pd, "notify::selected-printer", (GCallback) print_setup_changed_cb, op);
 486       g_signal_connect (pd, "notify::page-setup", (GCallback) print_setup_changed_cb, op);
 487     }
 488
 489   return pd;
 490 }
 491
 492 typedef struct
 493 {
 494   GtkPrintOperation           *op;
 495   gboolean                     do_print;
 496   gboolean                     do_preview;
 497   GtkPrintOperationResult      result;
 498   GtkPrintOperationPrintFunc   print_cb;
 499   GDestroyNotify               destroy;
 500   GtkWindow                   *parent;
 501   GMainLoop                   *loop;
 502 } PrintResponseData;
 503
 504 static void
 505 print_response_data_free (gpointer data)
 506 {
 507   PrintResponseData *rdata = data;
 508
 509   g_object_unref (rdata->op);
 510   g_free (rdata);
 511 }
 512
 513 static void
 514 finish_print (PrintResponseData *rdata,
 515               GtkPrinter        *printer,
 516               GtkPageSetup      *page_setup,
 517               GtkPrintSettings  *settings,
 518               gboolean           page_setup_set)
 519 {
 520   GtkPrintOperation *op = rdata->op;
 521   GtkPrintOperationPrivate *priv = op->priv;
 522   GtkPrintJob *job;
 523   gdouble top, bottom, left, right;
 524
 525   if (rdata->do_print)
 526     {
 527       gtk_print_operation_set_print_settings (op, settings);
 528       priv->print_context = _gtk_print_context_new (op);
 529
 530       if (gtk_print_settings_get_number_up (settings) < 2)
 531         {
 532           if (printer && gtk_printer_get_hard_margins (printer, &top, &bottom, &left, &right))
 533             _gtk_print_context_set_hard_margins (priv->print_context, top, bottom, left, right);
 534         }
 535       else
 536         {
 537           /* Pages do not have any unprintable area when printing n-up as each page on the
 538            * sheet has been scaled down and translated to a position within the printable
 539            * area of the sheet.
 540            */
 541           _gtk_print_context_set_hard_margins (priv->print_context, 0, 0, 0, 0);
 542         }
 543
 544       if (page_setup != NULL &&
 545           (gtk_print_operation_get_default_page_setup (op) == NULL ||
 546            page_setup_set))
 547         gtk_print_operation_set_default_page_setup (op, page_setup);
 548
 549       _gtk_print_context_set_page_setup (priv->print_context, page_setup);
 550
 551       if (!rdata->do_preview)
 552         {
 553           GtkPrintOperationUnix *op_unix;
 554           cairo_t *cr;
 555
 556           op_unix = g_new0 (GtkPrintOperationUnix, 1);
 557           priv->platform_data = op_unix;
 558           priv->free_platform_data = (GDestroyNotify) op_unix_free;
 559           op_unix->parent = rdata->parent;
 560
 561           priv->start_page = unix_start_page;
 562           priv->end_page = unix_end_page;
 563           priv->end_run = unix_end_run;
 564
 565           job = gtk_print_job_new (priv->job_name, printer, settings, page_setup);
 566           op_unix->job = job;
 567           gtk_print_job_set_track_print_status (job, priv->track_print_status);
 568
 569           op_unix->surface = gtk_print_job_get_surface (job, &priv->error);
 570           if (op_unix->surface == NULL)
 571             {
 572               rdata->result = GTK_PRINT_OPERATION_RESULT_ERROR;
 573               rdata->do_print = FALSE;
 574               goto out;
 575             }
 576
 577           cr = cairo_create (op_unix->surface);
 578           gtk_print_context_set_cairo_context (priv->print_context, cr, 72, 72);
 579           cairo_destroy (cr);
 580
 581           _gtk_print_operation_set_status (op, gtk_print_job_get_status (job), NULL);
 582
 583           op_unix->job_status_changed_tag =
 584             g_signal_connect (job, "status-changed",
 585                               G_CALLBACK (job_status_changed_cb), op);
 586
 587           priv->print_pages = gtk_print_job_get_pages (job);
 588           priv->page_ranges = gtk_print_job_get_page_ranges (job, &priv->num_page_ranges);
 589           priv->manual_num_copies = gtk_print_job_get_num_copies (job);
 590           priv->manual_collation = gtk_print_job_get_collate (job);
 591           priv->manual_reverse = gtk_print_job_get_reverse (job);
 592           priv->manual_page_set = gtk_print_job_get_page_set (job);
 593           priv->manual_scale = gtk_print_job_get_scale (job);
 594           priv->manual_orientation = gtk_print_job_get_rotate (job);
 595           priv->manual_number_up = gtk_print_job_get_n_up (job);
 596           priv->manual_number_up_layout = gtk_print_job_get_n_up_layout (job);
 597         }
 598     }
 599  out:
 600   if (rdata->print_cb)
 601     rdata->print_cb (op, rdata->parent, rdata->do_print, rdata->result);
 602
 603   if (rdata->destroy)
 604     rdata->destroy (rdata);
 605 }
 606
 607 static void
 608 handle_print_response (GtkWidget *dialog,
 609                        gint       response,
 610                        gpointer   data)
 611 {
 612   GtkPrintUnixDialog *pd = GTK_PRINT_UNIX_DIALOG (dialog);
 613   PrintResponseData *rdata = data;
 614   GtkPrintSettings *settings = NULL;
 615   GtkPageSetup *page_setup = NULL;
 616   GtkPrinter *printer = NULL;
 617   gboolean page_setup_set = FALSE;
 618
 619   if (response == GTK_RESPONSE_OK)
 620     {
 621       printer = gtk_print_unix_dialog_get_selected_printer (GTK_PRINT_UNIX_DIALOG (pd));
 622
 623       rdata->result = GTK_PRINT_OPERATION_RESULT_APPLY;
 624       rdata->do_preview = FALSE;
 625       if (printer != NULL)
 626         rdata->do_print = TRUE;
 627     }
 628   else if (response == GTK_RESPONSE_APPLY)
 629     {
 630       /* print preview */
 631       rdata->result = GTK_PRINT_OPERATION_RESULT_APPLY;
 632       rdata->do_preview = TRUE;
 633       rdata->do_print = TRUE;
 634
 635       rdata->op->priv->action = GTK_PRINT_OPERATION_ACTION_PREVIEW;
 636     }
 637
 638   if (rdata->do_print)
 639     {
 640       settings = gtk_print_unix_dialog_get_settings (GTK_PRINT_UNIX_DIALOG (pd));
 641       page_setup = gtk_print_unix_dialog_get_page_setup (GTK_PRINT_UNIX_DIALOG (pd));
 642       page_setup_set = gtk_print_unix_dialog_get_page_setup_set (GTK_PRINT_UNIX_DIALOG (pd));
 643
 644       /* Set new print settings now so that custom-widget options
 645        * can be added to the settings in the callback
 646        */
 647       gtk_print_operation_set_print_settings (rdata->op, settings);
 648       g_signal_emit_by_name (rdata->op, "custom-widget-apply", rdata->op->priv->custom_widget);
 649     }
 650
 651   finish_print (rdata, printer, page_setup, settings, page_setup_set);
 652
 653   if (settings)
 654     g_object_unref (settings);
 655
 656   gtk_widget_destroy (GTK_WIDGET (pd));
 657
 658 }
 659
 660
 661 static void
 662 found_printer (GtkPrinter        *printer,
 663                PrintResponseData *rdata)
 664 {
 665   GtkPrintOperation *op = rdata->op;
 666   GtkPrintOperationPrivate *priv = op->priv;
 667   GtkPrintSettings *settings = NULL;
 668   GtkPageSetup *page_setup = NULL;
 669
 670   if (rdata->loop)
 671     g_main_loop_quit (rdata->loop);
 672
 673   if (printer != NULL)
 674     {
 675       rdata->result = GTK_PRINT_OPERATION_RESULT_APPLY;
 676
 677       rdata->do_print = TRUE;
 678
 679       if (priv->print_settings)
 680         settings = gtk_print_settings_copy (priv->print_settings);
 681       else
 682         settings = gtk_print_settings_new ();
 683
 684       gtk_print_settings_set_printer (settings,
 685                                       gtk_printer_get_name (printer));
 686
 687       if (priv->default_page_setup)
 688         page_setup = gtk_page_setup_copy (priv->default_page_setup);
 689       else
 690         page_setup = gtk_page_setup_new ();
 691   }
 692
 693   finish_print (rdata, printer, page_setup, settings, FALSE);
 694
 695   if (settings)
 696     g_object_unref (settings);
 697
 698   if (page_setup)
 699     g_object_unref (page_setup);
 700 }
 701
 702 void
 703 _gtk_print_operation_platform_backend_run_dialog_async (GtkPrintOperation          *op,
 704                                                         gboolean                    show_dialog,
 705                                                         GtkWindow                  *parent,
 706                                                         GtkPrintOperationPrintFunc  print_cb)
 707 {
 708   GtkWidget *pd;
 709   PrintResponseData *rdata;
 710   const gchar *printer_name;
 711
 712   rdata = g_new (PrintResponseData, 1);
 713   rdata->op = g_object_ref (op);
 714   rdata->do_print = FALSE;
 715   rdata->do_preview = FALSE;
 716   rdata->result = GTK_PRINT_OPERATION_RESULT_CANCEL;
 717   rdata->print_cb = print_cb;
 718   rdata->parent = parent;
 719   rdata->loop = NULL;
 720   rdata->destroy = print_response_data_free;
 721
 722   if (show_dialog)
 723     {
 724       pd = get_print_dialog (op, parent);
 725       gtk_window_set_modal (GTK_WINDOW (pd), TRUE);
 726
 727       g_signal_connect (pd, "response",
 728                         G_CALLBACK (handle_print_response), rdata);
 729
 730       gtk_window_present (GTK_WINDOW (pd));
 731     }
 732   else
 733     {
 734       printer_name = NULL;
 735       if (op->priv->print_settings)
 736         printer_name = gtk_print_settings_get_printer (op->priv->print_settings);
 737
 738       find_printer (printer_name, (GFunc) found_printer, rdata);
 739     }
 740 }
 741
 742 static cairo_status_t
 743 write_preview (void                *closure,
 744                const unsigned char *data,
 745                unsigned int         length)
 746 {
 747   gint fd = GPOINTER_TO_INT (closure);
 748   gssize written;
 749
 750   while (length > 0)
 751     {
 752       written = write (fd, data, length);
 753
 754       if (written == -1)
 755         {
 756           if (errno == EAGAIN || errno == EINTR)
 757             continue;
 758
 759           return CAIRO_STATUS_WRITE_ERROR;
 760         }
 761
 762       data += written;
 763       length -= written;
 764     }
 765
 766   return CAIRO_STATUS_SUCCESS;
 767 }
 768
 769 static void
 770 close_preview (void *data)
 771 {
 772   gint fd = GPOINTER_TO_INT (data);
 773
 774   close (fd);
 775 }
 776
 777 cairo_surface_t *
 778 _gtk_print_operation_platform_backend_create_preview_surface (GtkPrintOperation *op,
 779                                                               GtkPageSetup      *page_setup,
 780                                                               gdouble           *dpi_x,
 781                                                               gdouble           *dpi_y,
 782                                                               gchar            **target)
 783 {
 784   gchar *filename;
 785   gint fd;
 786   GtkPaperSize *paper_size;
 787   gdouble w, h;
 788   cairo_surface_t *surface;
 789   static cairo_user_data_key_t key;
 790
 791   filename = g_build_filename (g_get_tmp_dir (), "previewXXXXXX.pdf", NULL);
 792   fd = g_mkstemp (filename);
 793
 794   if (fd < 0)
 795     {
 796       g_free (filename);
 797       return NULL;
 798     }
 799
 800   *target = filename;
 801
 802   paper_size = gtk_page_setup_get_paper_size (page_setup);
 803   w = gtk_paper_size_get_width (paper_size, GTK_UNIT_POINTS);
 804   h = gtk_paper_size_get_height (paper_size, GTK_UNIT_POINTS);
 805
 806   *dpi_x = *dpi_y = 72;
 807   surface = cairo_pdf_surface_create_for_stream (write_preview, GINT_TO_POINTER (fd), w, h);
 808
 809   cairo_surface_set_user_data (surface, &key, GINT_TO_POINTER (fd), close_preview);
 810
 811   return surface;
 812 }
 813
 814 void
 815 _gtk_print_operation_platform_backend_preview_start_page (GtkPrintOperation *op,
 816                                                           cairo_surface_t   *surface,
 817                                                           cairo_t           *cr)
 818 {
 819 }
 820
 821 void
 822 _gtk_print_operation_platform_backend_preview_end_page (GtkPrintOperation *op,
 823                                                         cairo_surface_t   *surface,
 824                                                         cairo_t           *cr)
 825 {
 826   cairo_show_page (cr);
 827 }
 828
 829 void
 830 _gtk_print_operation_platform_backend_resize_preview_surface (GtkPrintOperation *op,
 831                                                               GtkPageSetup      *page_setup,
 832                                                               cairo_surface_t   *surface)
 833 {
 834   GtkPaperSize *paper_size;
 835   gdouble w, h;
 836
 837   paper_size = gtk_page_setup_get_paper_size (page_setup);
 838   w = gtk_paper_size_get_width (paper_size, GTK_UNIT_POINTS);
 839   h = gtk_paper_size_get_height (paper_size, GTK_UNIT_POINTS);
 840   cairo_pdf_surface_set_size (surface, w, h);
 841 }
 842
 843
 844 GtkPrintOperationResult
 845 _gtk_print_operation_platform_backend_run_dialog (GtkPrintOperation *op,
 846                                                   gboolean           show_dialog,
 847                                                   GtkWindow         *parent,
 848                                                   gboolean          *do_print)
 849  {
 850   GtkWidget *pd;
 851   PrintResponseData rdata;
 852   gint response;
 853   const gchar *printer_name;
 854
 855   rdata.op = op;
 856   rdata.do_print = FALSE;
 857   rdata.do_preview = FALSE;
 858   rdata.result = GTK_PRINT_OPERATION_RESULT_CANCEL;
 859   rdata.print_cb = NULL;
 860   rdata.destroy = NULL;
 861   rdata.parent = parent;
 862   rdata.loop = NULL;
 863
 864   if (show_dialog)
 865     {
 866       pd = get_print_dialog (op, parent);
 867
 868       response = gtk_dialog_run (GTK_DIALOG (pd));
 869       handle_print_response (pd, response, &rdata);
 870     }
 871   else
 872     {
 873       printer_name = NULL;
 874       if (op->priv->print_settings)
 875         printer_name = gtk_print_settings_get_printer (op->priv->print_settings);
 876
 877       rdata.loop = g_main_loop_new (NULL, FALSE);
 878       find_printer (printer_name,
 879                     (GFunc) found_printer, &rdata);
 880
 881       GDK_THREADS_LEAVE ();
 882       g_main_loop_run (rdata.loop);
 883       GDK_THREADS_ENTER ();
 884
 885       g_main_loop_unref (rdata.loop);
 886       rdata.loop = NULL;
 887     }
 888
 889   *do_print = rdata.do_print;
 890
 891   return rdata.result;
 892 }
 893
 894
 895 typedef struct
 896 {
 897   GtkPageSetup         *page_setup;
 898   GtkPageSetupDoneFunc  done_cb;
 899   gpointer              data;
 900   GDestroyNotify        destroy;
 901 } PageSetupResponseData;
 902
 903 static void
 904 page_setup_data_free (gpointer data)
 905 {
 906   PageSetupResponseData *rdata = data;
 907
 908   if (rdata->page_setup)
 909     g_object_unref (rdata->page_setup);
 910
 911   g_free (rdata);
 912 }
 913
 914 static void
 915 handle_page_setup_response (GtkWidget *dialog,
 916                             gint       response,
 917                             gpointer   data)
 918 {
 919   GtkPageSetupUnixDialog *psd;
 920   PageSetupResponseData *rdata = data;
 921
 922   psd = GTK_PAGE_SETUP_UNIX_DIALOG (dialog);
 923   if (response == GTK_RESPONSE_OK)
 924     rdata->page_setup = gtk_page_setup_unix_dialog_get_page_setup (psd);
 925
 926   gtk_widget_destroy (dialog);
 927
 928   if (rdata->done_cb)
 929     rdata->done_cb (rdata->page_setup, rdata->data);
 930
 931   if (rdata->destroy)
 932     rdata->destroy (rdata);
 933 }
 934
 935 static GtkWidget *
 936 get_page_setup_dialog (GtkWindow        *parent,
 937                        GtkPageSetup     *page_setup,
 938                        GtkPrintSettings *settings)
 939 {
 940   GtkWidget *dialog;
 941
 942   dialog = gtk_page_setup_unix_dialog_new (NULL, parent);
 943   if (page_setup)
 944     gtk_page_setup_unix_dialog_set_page_setup (GTK_PAGE_SETUP_UNIX_DIALOG (dialog),
 945                                                page_setup);
 946   gtk_page_setup_unix_dialog_set_print_settings (GTK_PAGE_SETUP_UNIX_DIALOG (dialog),
 947                                                  settings);
 948
 949   return dialog;
 950 }
 951
 952 /**
 953  * gtk_print_run_page_setup_dialog:
 954  * @parent: (allow-none): transient parent
 955  * @page_setup: (allow-none): an existing #GtkPageSetup
 956  * @settings: a #GtkPrintSettings
 957  *
 958  * Runs a page setup dialog, letting the user modify the values from
 959  * @page_setup. If the user cancels the dialog, the returned #GtkPageSetup
 960  * is identical to the passed in @page_setup, otherwise it contains the
 961  * modifications done in the dialog.
 962  *
 963  * Note that this function may use a recursive mainloop to show the page
 964  * setup dialog. See gtk_print_run_page_setup_dialog_async() if this is
 965  * a problem.
 966  *
 967  * Return value: (transfer full): a new #GtkPageSetup
 968  *
 969  * Since: 2.10
 970  */
 971 GtkPageSetup *
 972 gtk_print_run_page_setup_dialog (GtkWindow        *parent,
 973                                  GtkPageSetup     *page_setup,
 974                                  GtkPrintSettings *settings)
 975 {
 976   GtkWidget *dialog;
 977   gint response;
 978   PageSetupResponseData rdata;
 979
 980   rdata.page_setup = NULL;
 981   rdata.done_cb = NULL;
 982   rdata.data = NULL;
 983   rdata.destroy = NULL;
 984
 985   dialog = get_page_setup_dialog (parent, page_setup, settings);
 986   response = gtk_dialog_run (GTK_DIALOG (dialog));
 987   handle_page_setup_response (dialog, response, &rdata);
 988
 989   if (rdata.page_setup)
 990     return rdata.page_setup;
 991   else if (page_setup)
 992     return gtk_page_setup_copy (page_setup);
 993   else
 994     return gtk_page_setup_new ();
 995 }
 996
 997 /**
 998  * gtk_print_run_page_setup_dialog_async:
 999  * @parent: (allow-none): transient parent, or %NULL
1000  * @page_setup: (allow-none): an existing #GtkPageSetup, or %NULL
1001  * @settings: a #GtkPrintSettings
1002  * @done_cb: (scope async): a function to call when the user saves
1003  *           the modified page setup
1004  * @data: user data to pass to @done_cb
1005  *
1006  * Runs a page setup dialog, letting the user modify the values from @page_setup.
1007  *
1008  * In contrast to gtk_print_run_page_setup_dialog(), this function  returns after
1009  * showing the page setup dialog on platforms that support this, and calls @done_cb
1010  * from a signal handler for the ::response signal of the dialog.
1011  *
1012  * Since: 2.10
1013  */
1014 void
1015 gtk_print_run_page_setup_dialog_async (GtkWindow            *parent,
1016                                        GtkPageSetup         *page_setup,
1017                                        GtkPrintSettings     *settings,
1018                                        GtkPageSetupDoneFunc  done_cb,
1019                                        gpointer              data)
1020 {
1021   GtkWidget *dialog;
1022   PageSetupResponseData *rdata;
1023
1024   dialog = get_page_setup_dialog (parent, page_setup, settings);
1025   gtk_window_set_modal (GTK_WINDOW (dialog), TRUE);
1026
1027   rdata = g_new (PageSetupResponseData, 1);
1028   rdata->page_setup = NULL;
1029   rdata->done_cb = done_cb;
1030   rdata->data = data;
1031   rdata->destroy = page_setup_data_free;
1032
1033   g_signal_connect (dialog, "response",
1034                     G_CALLBACK (handle_page_setup_response), rdata);
1035
1036   gtk_window_present (GTK_WINDOW (dialog));
1037  }
1038
1039 struct _PrinterFinder
1040 {
1041   gboolean found_printer;
1042   GFunc func;
1043   gpointer data;
1044   gchar *printer_name;
1045   GList *backends;
1046   guint timeout_tag;
1047   GtkPrinter *printer;
1048   GtkPrinter *default_printer;
1049   GtkPrinter *first_printer;
1050 };
1051
1052 static gboolean
1053 find_printer_idle (gpointer data)
1054 {
1055   PrinterFinder *finder = data;
1056   GtkPrinter *printer;
1057
1058   if (finder->printer != NULL)
1059     printer = finder->printer;
1060   else if (finder->default_printer != NULL)
1061     printer = finder->default_printer;
1062   else if (finder->first_printer != NULL)
1063     printer = finder->first_printer;
1064   else
1065     printer = NULL;
1066
1067   finder->func (printer, finder->data);
1068
1069   printer_finder_free (finder);
1070
1071   return FALSE;
1072 }
1073
1074 static void
1075 printer_added_cb (GtkPrintBackend *backend,
1076                   GtkPrinter      *printer,
1077                   PrinterFinder   *finder)
1078 {
1079   if (finder->found_printer)
1080     return;
1081
1082   /* FIXME this skips "Print to PDF" - is this intentional ? */
1083   if (gtk_printer_is_virtual (printer))
1084     return;
1085
1086   if (finder->printer_name != NULL &&
1087       strcmp (gtk_printer_get_name (printer), finder->printer_name) == 0)
1088     {
1089       finder->printer = g_object_ref (printer);
1090       finder->found_printer = TRUE;
1091     }
1092   else if (finder->default_printer == NULL &&
1093            gtk_printer_is_default (printer))
1094     {
1095       finder->default_printer = g_object_ref (printer);
1096       if (finder->printer_name == NULL)
1097         finder->found_printer = TRUE;
1098     }
1099   else
1100     if (finder->first_printer == NULL)
1101       finder->first_printer = g_object_ref (printer);
1102
1103   if (finder->found_printer)
1104     g_idle_add (find_printer_idle, finder);
1105 }
1106
1107 static void
1108 printer_list_done_cb (GtkPrintBackend *backend,
1109                       PrinterFinder   *finder)
1110 {
1111   finder->backends = g_list_remove (finder->backends, backend);
1112
1113   g_signal_handlers_disconnect_by_func (backend, printer_added_cb, finder);
1114   g_signal_handlers_disconnect_by_func (backend, printer_list_done_cb, finder);
1115
1116   gtk_print_backend_destroy (backend);
1117   g_object_unref (backend);
1118
1119   if (finder->backends == NULL && !finder->found_printer)
1120     g_idle_add (find_printer_idle, finder);
1121 }
1122
1123 static void
1124 find_printer_init (PrinterFinder   *finder,
1125                    GtkPrintBackend *backend)
1126 {
1127   GList *list;
1128   GList *node;
1129
1130   list = gtk_print_backend_get_printer_list (backend);
1131
1132   node = list;
1133   while (node != NULL)
1134     {
1135       printer_added_cb (backend, node->data, finder);
1136       node = node->next;
1137
1138       if (finder->found_printer)
1139         break;
1140     }
1141
1142   g_list_free (list);
1143
1144   if (gtk_print_backend_printer_list_is_done (backend))
1145     {
1146       finder->backends = g_list_remove (finder->backends, backend);
1147       gtk_print_backend_destroy (backend);
1148       g_object_unref (backend);
1149     }
1150   else
1151     {
1152       g_signal_connect (backend, "printer-added",
1153                         (GCallback) printer_added_cb,
1154                         finder);
1155       g_signal_connect (backend, "printer-list-done",
1156                         (GCallback) printer_list_done_cb,
1157                         finder);
1158     }
1159
1160 }
1161
1162 static void
1163 printer_finder_free (PrinterFinder *finder)
1164 {
1165   GList *l;
1166
1167   g_free (finder->printer_name);
1168
1169   if (finder->printer)
1170     g_object_unref (finder->printer);
1171
1172   if (finder->default_printer)
1173     g_object_unref (finder->default_printer);
1174
1175   if (finder->first_printer)
1176     g_object_unref (finder->first_printer);
1177
1178   for (l = finder->backends; l != NULL; l = l->next)
1179     {
1180       GtkPrintBackend *backend = l->data;
1181       g_signal_handlers_disconnect_by_func (backend, printer_added_cb, finder);
1182       g_signal_handlers_disconnect_by_func (backend, printer_list_done_cb, finder);
1183       gtk_print_backend_destroy (backend);
1184       g_object_unref (backend);
1185     }
1186
1187   g_list_free (finder->backends);
1188
1189   g_free (finder);
1190 }
1191
1192 static void
1193 find_printer (const gchar *printer,
1194               GFunc        func,
1195               gpointer     data)
1196 {
1197   GList *node, *next;
1198   PrinterFinder *finder;
1199
1200   finder = g_new0 (PrinterFinder, 1);
1201
1202   finder->printer_name = g_strdup (printer);
1203   finder->func = func;
1204   finder->data = data;
1205
1206   finder->backends = NULL;
1207   if (g_module_supported ())
1208     finder->backends = gtk_print_backend_load_modules ();
1209
1210   for (node = finder->backends; !finder->found_printer && node != NULL; node = next)
1211     {
1212       next = node->next;
1213       find_printer_init (finder, GTK_PRINT_BACKEND (node->data));
1214     }
1215
1216   if (finder->backends == NULL && !finder->found_printer)
1217     g_idle_add (find_printer_idle, finder);
1218 }