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 #include "gtkalias.h"
  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   gint argc;
 205   gchar **argv;
 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   g_shell_parse_argv (cmd, &argc, &argv, &error);
 280
 281   g_free (preview_cmd);
 282   g_free (quoted_filename);
 283   g_free (quoted_settings_filename);
 284   g_free (cmd);
 285
 286   if (error != NULL)
 287     goto out;
 288
 289   gdk_spawn_on_screen (screen, NULL, argv, NULL, G_SPAWN_SEARCH_PATH, NULL, NULL, NULL, &error);
 290
 291   g_strfreev (argv);
 292
 293   if (error != NULL)
 294     {
 295       gchar* uri;
 296
 297       g_warning ("%s %s", _("Error launching preview"), error->message);
 298
 299       g_error_free (error);
 300       error = NULL;
 301       uri = g_filename_to_uri (filename, NULL, NULL);
 302       gtk_show_uri (screen, uri, GDK_CURRENT_TIME, &error);
 303       g_free (uri);
 304     }
 305
 306  out:
 307   if (error != NULL)
 308     {
 309       if (op->priv->error == NULL)
 310         op->priv->error = error;
 311       else
 312         g_error_free (error);
 313
 314       filename_used = FALSE;
 315       settings_used = FALSE;
 316    }
 317
 318   if (!filename_used)
 319     g_unlink (filename);
 320
 321   if (!settings_used)
 322     g_unlink (settings_filename);
 323
 324   if (fd > 0)
 325     close (fd);
 326
 327   if (key_file)
 328     g_key_file_free (key_file);
 329   g_free (data);
 330   g_free (settings_filename);
 331 }
 332
 333 static void
 334 unix_finish_send  (GtkPrintJob  *job,
 335                    gpointer      user_data,
 336                    const GError *error)
 337 {
 338   GtkPrintOperation *op = (GtkPrintOperation *) user_data;
 339   GtkPrintOperationUnix *op_unix = op->priv->platform_data;
 340
 341   if (error != NULL && op->priv->error == NULL)
 342     op->priv->error = g_error_copy (error);
 343
 344   op_unix->data_sent = TRUE;
 345
 346   if (op_unix->loop)
 347     g_main_loop_quit (op_unix->loop);
 348
 349   g_object_unref (op);
 350 }
 351
 352 static void
 353 unix_end_run (GtkPrintOperation *op,
 354               gboolean           wait,
 355               gboolean           cancelled)
 356 {
 357   GtkPrintOperationUnix *op_unix = op->priv->platform_data;
 358
 359   cairo_surface_finish (op_unix->surface);
 360
 361   if (cancelled)
 362     return;
 363
 364   if (wait)
 365     op_unix->loop = g_main_loop_new (NULL, FALSE);
 366
 367   /* TODO: Check for error */
 368   if (op_unix->job != NULL)
 369     {
 370       g_object_ref (op);
 371       gtk_print_job_send (op_unix->job,
 372                           unix_finish_send,
 373                           op, NULL);
 374     }
 375
 376   if (wait)
 377     {
 378       g_object_ref (op);
 379       if (!op_unix->data_sent)
 380         {
 381           GDK_THREADS_LEAVE ();
 382           g_main_loop_run (op_unix->loop);
 383           GDK_THREADS_ENTER ();
 384         }
 385       g_main_loop_unref (op_unix->loop);
 386       op_unix->loop = NULL;
 387       g_object_unref (op);
 388     }
 389 }
 390
 391 static void
 392 job_status_changed_cb (GtkPrintJob       *job,
 393                        GtkPrintOperation *op)
 394 {
 395   _gtk_print_operation_set_status (op, gtk_print_job_get_status (job), NULL);
 396 }
 397
 398
 399 static void
 400 print_setup_changed_cb (GtkPrintUnixDialog *print_dialog,
 401                         GParamSpec         *pspec,
 402                         gpointer            user_data)
 403 {
 404   GtkPageSetup             *page_setup;
 405   GtkPrintSettings         *print_settings;
 406   GtkPrintOperation        *op = user_data;
 407   GtkPrintOperationPrivate *priv = op->priv;
 408
 409   page_setup = gtk_print_unix_dialog_get_page_setup (print_dialog);
 410   print_settings = gtk_print_unix_dialog_get_settings (print_dialog);
 411
 412   g_signal_emit_by_name (op,
 413                          "update-custom-widget",
 414                          priv->custom_widget,
 415                          page_setup,
 416                          print_settings);
 417 }
 418
 419 static GtkWidget *
 420 get_print_dialog (GtkPrintOperation *op,
 421                   GtkWindow         *parent)
 422 {
 423   GtkPrintOperationPrivate *priv = op->priv;
 424   GtkWidget *pd, *label;
 425   const gchar *custom_tab_label;
 426
 427   pd = gtk_print_unix_dialog_new (NULL, parent);
 428
 429   gtk_print_unix_dialog_set_manual_capabilities (GTK_PRINT_UNIX_DIALOG (pd),
 430                                                  GTK_PRINT_CAPABILITY_PAGE_SET |
 431                                                  GTK_PRINT_CAPABILITY_COPIES |
 432                                                  GTK_PRINT_CAPABILITY_COLLATE |
 433                                                  GTK_PRINT_CAPABILITY_REVERSE |
 434                                                  GTK_PRINT_CAPABILITY_SCALE |
 435                                                  GTK_PRINT_CAPABILITY_PREVIEW |
 436                                                  GTK_PRINT_CAPABILITY_NUMBER_UP |
 437                                                  GTK_PRINT_CAPABILITY_NUMBER_UP_LAYOUT);
 438
 439   if (priv->print_settings)
 440     gtk_print_unix_dialog_set_settings (GTK_PRINT_UNIX_DIALOG (pd),
 441                                         priv->print_settings);
 442
 443   if (priv->default_page_setup)
 444     gtk_print_unix_dialog_set_page_setup (GTK_PRINT_UNIX_DIALOG (pd),
 445                                           priv->default_page_setup);
 446
 447   gtk_print_unix_dialog_set_embed_page_setup (GTK_PRINT_UNIX_DIALOG (pd),
 448                                               priv->embed_page_setup);
 449
 450   gtk_print_unix_dialog_set_current_page (GTK_PRINT_UNIX_DIALOG (pd),
 451                                           priv->current_page);
 452
 453   gtk_print_unix_dialog_set_support_selection (GTK_PRINT_UNIX_DIALOG (pd),
 454                                                priv->support_selection);
 455
 456   gtk_print_unix_dialog_set_has_selection (GTK_PRINT_UNIX_DIALOG (pd),
 457                                            priv->has_selection);
 458
 459   g_signal_emit_by_name (op, "create-custom-widget",
 460                          &priv->custom_widget);
 461
 462   if (priv->custom_widget)
 463     {
 464       custom_tab_label = priv->custom_tab_label;
 465
 466       if (custom_tab_label == NULL)
 467         {
 468           custom_tab_label = g_get_application_name ();
 469           if (custom_tab_label == NULL)
 470             custom_tab_label = _("Application");
 471         }
 472
 473       label = gtk_label_new (custom_tab_label);
 474
 475       gtk_print_unix_dialog_add_custom_tab (GTK_PRINT_UNIX_DIALOG (pd),
 476                                             priv->custom_widget, label);
 477
 478       g_signal_connect (pd, "notify::selected-printer", (GCallback) print_setup_changed_cb, op);
 479       g_signal_connect (pd, "notify::page-setup", (GCallback) print_setup_changed_cb, op);
 480     }
 481
 482   return pd;
 483 }
 484
 485 typedef struct
 486 {
 487   GtkPrintOperation           *op;
 488   gboolean                     do_print;
 489   gboolean                     do_preview;
 490   GtkPrintOperationResult      result;
 491   GtkPrintOperationPrintFunc   print_cb;
 492   GDestroyNotify               destroy;
 493   GtkWindow                   *parent;
 494   GMainLoop                   *loop;
 495 } PrintResponseData;
 496
 497 static void
 498 print_response_data_free (gpointer data)
 499 {
 500   PrintResponseData *rdata = data;
 501
 502   g_object_unref (rdata->op);
 503   g_free (rdata);
 504 }
 505
 506 static void
 507 finish_print (PrintResponseData *rdata,
 508               GtkPrinter        *printer,
 509               GtkPageSetup      *page_setup,
 510               GtkPrintSettings  *settings,
 511               gboolean           page_setup_set)
 512 {
 513   GtkPrintOperation *op = rdata->op;
 514   GtkPrintOperationPrivate *priv = op->priv;
 515   GtkPrintJob *job;
 516   gdouble top, bottom, left, right;
 517
 518   if (rdata->do_print)
 519     {
 520       gtk_print_operation_set_print_settings (op, settings);
 521       priv->print_context = _gtk_print_context_new (op);
 522
 523       if (gtk_print_settings_get_number_up (settings) < 2)
 524         {
 525           if (printer && gtk_printer_get_hard_margins (printer, &top, &bottom, &left, &right))
 526             _gtk_print_context_set_hard_margins (priv->print_context, top, bottom, left, right);
 527         }
 528       else
 529         {
 530           /* Pages do not have any unprintable area when printing n-up as each page on the
 531            * sheet has been scaled down and translated to a position within the printable
 532            * area of the sheet.
 533            */
 534           _gtk_print_context_set_hard_margins (priv->print_context, 0, 0, 0, 0);
 535         }
 536
 537       if (page_setup != NULL &&
 538           (gtk_print_operation_get_default_page_setup (op) == NULL ||
 539            page_setup_set))
 540         gtk_print_operation_set_default_page_setup (op, page_setup);
 541
 542       _gtk_print_context_set_page_setup (priv->print_context, page_setup);
 543
 544       if (!rdata->do_preview)
 545         {
 546           GtkPrintOperationUnix *op_unix;
 547           cairo_t *cr;
 548
 549           op_unix = g_new0 (GtkPrintOperationUnix, 1);
 550           priv->platform_data = op_unix;
 551           priv->free_platform_data = (GDestroyNotify) op_unix_free;
 552           op_unix->parent = rdata->parent;
 553
 554           priv->start_page = unix_start_page;
 555           priv->end_page = unix_end_page;
 556           priv->end_run = unix_end_run;
 557
 558           job = gtk_print_job_new (priv->job_name, printer, settings, page_setup);
 559           op_unix->job = job;
 560           gtk_print_job_set_track_print_status (job, priv->track_print_status);
 561
 562           op_unix->surface = gtk_print_job_get_surface (job, &priv->error);
 563           if (op_unix->surface == NULL)
 564             {
 565               rdata->result = GTK_PRINT_OPERATION_RESULT_ERROR;
 566               rdata->do_print = FALSE;
 567               goto out;
 568             }
 569
 570           cr = cairo_create (op_unix->surface);
 571           gtk_print_context_set_cairo_context (priv->print_context, cr, 72, 72);
 572           cairo_destroy (cr);
 573
 574           _gtk_print_operation_set_status (op, gtk_print_job_get_status (job), NULL);
 575
 576           op_unix->job_status_changed_tag =
 577             g_signal_connect (job, "status-changed",
 578                               G_CALLBACK (job_status_changed_cb), op);
 579
 580           priv->print_pages = job->print_pages;
 581           priv->page_ranges = job->page_ranges;
 582           priv->num_page_ranges = job->num_page_ranges;
 583
 584           priv->manual_num_copies = job->num_copies;
 585           priv->manual_collation = job->collate;
 586           priv->manual_reverse = job->reverse;
 587           priv->manual_page_set = job->page_set;
 588           priv->manual_scale = job->scale;
 589           priv->manual_orientation = job->rotate_to_orientation;
 590           priv->manual_number_up = job->number_up;
 591           priv->manual_number_up_layout = job->number_up_layout;
 592         }
 593     }
 594  out:
 595   if (rdata->print_cb)
 596     rdata->print_cb (op, rdata->parent, rdata->do_print, rdata->result);
 597
 598   if (rdata->destroy)
 599     rdata->destroy (rdata);
 600 }
 601
 602 static void
 603 handle_print_response (GtkWidget *dialog,
 604                        gint       response,
 605                        gpointer   data)
 606 {
 607   GtkPrintUnixDialog *pd = GTK_PRINT_UNIX_DIALOG (dialog);
 608   PrintResponseData *rdata = data;
 609   GtkPrintSettings *settings = NULL;
 610   GtkPageSetup *page_setup = NULL;
 611   GtkPrinter *printer = NULL;
 612   gboolean page_setup_set = FALSE;
 613
 614   if (response == GTK_RESPONSE_OK)
 615     {
 616       printer = gtk_print_unix_dialog_get_selected_printer (GTK_PRINT_UNIX_DIALOG (pd));
 617
 618       rdata->result = GTK_PRINT_OPERATION_RESULT_APPLY;
 619       rdata->do_preview = FALSE;
 620       if (printer != NULL)
 621         rdata->do_print = TRUE;
 622     }
 623   else if (response == GTK_RESPONSE_APPLY)
 624     {
 625       /* print preview */
 626       rdata->result = GTK_PRINT_OPERATION_RESULT_APPLY;
 627       rdata->do_preview = TRUE;
 628       rdata->do_print = TRUE;
 629
 630       rdata->op->priv->action = GTK_PRINT_OPERATION_ACTION_PREVIEW;
 631     }
 632
 633   if (rdata->do_print)
 634     {
 635       settings = gtk_print_unix_dialog_get_settings (GTK_PRINT_UNIX_DIALOG (pd));
 636       page_setup = gtk_print_unix_dialog_get_page_setup (GTK_PRINT_UNIX_DIALOG (pd));
 637       page_setup_set = gtk_print_unix_dialog_get_page_setup_set (GTK_PRINT_UNIX_DIALOG (pd));
 638
 639       g_signal_emit_by_name (rdata->op, "custom-widget-apply", rdata->op->priv->custom_widget);
 640     }
 641
 642   finish_print (rdata, printer, page_setup, settings, page_setup_set);
 643
 644   if (settings)
 645     g_object_unref (settings);
 646
 647   gtk_widget_destroy (GTK_WIDGET (pd));
 648
 649 }
 650
 651
 652 static void
 653 found_printer (GtkPrinter        *printer,
 654                PrintResponseData *rdata)
 655 {
 656   GtkPrintOperation *op = rdata->op;
 657   GtkPrintOperationPrivate *priv = op->priv;
 658   GtkPrintSettings *settings = NULL;
 659   GtkPageSetup *page_setup = NULL;
 660
 661   if (rdata->loop)
 662     g_main_loop_quit (rdata->loop);
 663
 664   if (printer != NULL)
 665     {
 666       rdata->result = GTK_PRINT_OPERATION_RESULT_APPLY;
 667
 668       rdata->do_print = TRUE;
 669
 670       if (priv->print_settings)
 671         settings = gtk_print_settings_copy (priv->print_settings);
 672       else
 673         settings = gtk_print_settings_new ();
 674
 675       gtk_print_settings_set_printer (settings,
 676                                       gtk_printer_get_name (printer));
 677
 678       if (priv->default_page_setup)
 679         page_setup = gtk_page_setup_copy (priv->default_page_setup);
 680       else
 681         page_setup = gtk_page_setup_new ();
 682   }
 683
 684   finish_print (rdata, printer, page_setup, settings, FALSE);
 685
 686   if (settings)
 687     g_object_unref (settings);
 688
 689   if (page_setup)
 690     g_object_unref (page_setup);
 691 }
 692
 693 void
 694 _gtk_print_operation_platform_backend_run_dialog_async (GtkPrintOperation          *op,
 695                                                         gboolean                    show_dialog,
 696                                                         GtkWindow                  *parent,
 697                                                         GtkPrintOperationPrintFunc  print_cb)
 698 {
 699   GtkWidget *pd;
 700   PrintResponseData *rdata;
 701   const gchar *printer_name;
 702
 703   rdata = g_new (PrintResponseData, 1);
 704   rdata->op = g_object_ref (op);
 705   rdata->do_print = FALSE;
 706   rdata->do_preview = FALSE;
 707   rdata->result = GTK_PRINT_OPERATION_RESULT_CANCEL;
 708   rdata->print_cb = print_cb;
 709   rdata->parent = parent;
 710   rdata->loop = NULL;
 711   rdata->destroy = print_response_data_free;
 712
 713   if (show_dialog)
 714     {
 715       pd = get_print_dialog (op, parent);
 716       gtk_window_set_modal (GTK_WINDOW (pd), TRUE);
 717
 718       g_signal_connect (pd, "response",
 719                         G_CALLBACK (handle_print_response), rdata);
 720
 721       gtk_window_present (GTK_WINDOW (pd));
 722     }
 723   else
 724     {
 725       printer_name = NULL;
 726       if (op->priv->print_settings)
 727         printer_name = gtk_print_settings_get_printer (op->priv->print_settings);
 728
 729       find_printer (printer_name, (GFunc) found_printer, rdata);
 730     }
 731 }
 732
 733 static cairo_status_t
 734 write_preview (void                *closure,
 735                const unsigned char *data,
 736                unsigned int         length)
 737 {
 738   gint fd = GPOINTER_TO_INT (closure);
 739   gssize written;
 740
 741   while (length > 0)
 742     {
 743       written = write (fd, data, length);
 744
 745       if (written == -1)
 746         {
 747           if (errno == EAGAIN || errno == EINTR)
 748             continue;
 749
 750           return CAIRO_STATUS_WRITE_ERROR;
 751         }
 752
 753       data += written;
 754       length -= written;
 755     }
 756
 757   return CAIRO_STATUS_SUCCESS;
 758 }
 759
 760 static void
 761 close_preview (void *data)
 762 {
 763   gint fd = GPOINTER_TO_INT (data);
 764
 765   close (fd);
 766 }
 767
 768 cairo_surface_t *
 769 _gtk_print_operation_platform_backend_create_preview_surface (GtkPrintOperation *op,
 770                                                               GtkPageSetup      *page_setup,
 771                                                               gdouble           *dpi_x,
 772                                                               gdouble           *dpi_y,
 773                                                               gchar            **target)
 774 {
 775   gchar *filename;
 776   gint fd;
 777   GtkPaperSize *paper_size;
 778   gdouble w, h;
 779   cairo_surface_t *surface;
 780   static cairo_user_data_key_t key;
 781
 782   filename = g_build_filename (g_get_tmp_dir (), "previewXXXXXX.pdf", NULL);
 783   fd = g_mkstemp (filename);
 784
 785   if (fd < 0)
 786     {
 787       g_free (filename);
 788       return NULL;
 789     }
 790
 791   *target = filename;
 792
 793   paper_size = gtk_page_setup_get_paper_size (page_setup);
 794   w = gtk_paper_size_get_width (paper_size, GTK_UNIT_POINTS);
 795   h = gtk_paper_size_get_height (paper_size, GTK_UNIT_POINTS);
 796
 797   *dpi_x = *dpi_y = 72;
 798   surface = cairo_pdf_surface_create_for_stream (write_preview, GINT_TO_POINTER (fd), w, h);
 799
 800   cairo_surface_set_user_data (surface, &key, GINT_TO_POINTER (fd), close_preview);
 801
 802   return surface;
 803 }
 804
 805 void
 806 _gtk_print_operation_platform_backend_preview_start_page (GtkPrintOperation *op,
 807                                                           cairo_surface_t   *surface,
 808                                                           cairo_t           *cr)
 809 {
 810 }
 811
 812 void
 813 _gtk_print_operation_platform_backend_preview_end_page (GtkPrintOperation *op,
 814                                                         cairo_surface_t   *surface,
 815                                                         cairo_t           *cr)
 816 {
 817   cairo_show_page (cr);
 818 }
 819
 820 void
 821 _gtk_print_operation_platform_backend_resize_preview_surface (GtkPrintOperation *op,
 822                                                               GtkPageSetup      *page_setup,
 823                                                               cairo_surface_t   *surface)
 824 {
 825   GtkPaperSize *paper_size;
 826   gdouble w, h;
 827
 828   paper_size = gtk_page_setup_get_paper_size (page_setup);
 829   w = gtk_paper_size_get_width (paper_size, GTK_UNIT_POINTS);
 830   h = gtk_paper_size_get_height (paper_size, GTK_UNIT_POINTS);
 831   cairo_pdf_surface_set_size (surface, w, h);
 832 }
 833
 834
 835 GtkPrintOperationResult
 836 _gtk_print_operation_platform_backend_run_dialog (GtkPrintOperation *op,
 837                                                   gboolean           show_dialog,
 838                                                   GtkWindow         *parent,
 839                                                   gboolean          *do_print)
 840  {
 841   GtkWidget *pd;
 842   PrintResponseData rdata;
 843   gint response;
 844   const gchar *printer_name;
 845
 846   rdata.op = op;
 847   rdata.do_print = FALSE;
 848   rdata.do_preview = FALSE;
 849   rdata.result = GTK_PRINT_OPERATION_RESULT_CANCEL;
 850   rdata.print_cb = NULL;
 851   rdata.destroy = NULL;
 852   rdata.parent = parent;
 853   rdata.loop = NULL;
 854
 855   if (show_dialog)
 856     {
 857       pd = get_print_dialog (op, parent);
 858
 859       response = gtk_dialog_run (GTK_DIALOG (pd));
 860       handle_print_response (pd, response, &rdata);
 861     }
 862   else
 863     {
 864       printer_name = NULL;
 865       if (op->priv->print_settings)
 866         printer_name = gtk_print_settings_get_printer (op->priv->print_settings);
 867
 868       rdata.loop = g_main_loop_new (NULL, FALSE);
 869       find_printer (printer_name,
 870                     (GFunc) found_printer, &rdata);
 871
 872       GDK_THREADS_LEAVE ();
 873       g_main_loop_run (rdata.loop);
 874       GDK_THREADS_ENTER ();
 875
 876       g_main_loop_unref (rdata.loop);
 877       rdata.loop = NULL;
 878     }
 879
 880   *do_print = rdata.do_print;
 881
 882   return rdata.result;
 883 }
 884
 885
 886 typedef struct
 887 {
 888   GtkPageSetup         *page_setup;
 889   GtkPageSetupDoneFunc  done_cb;
 890   gpointer              data;
 891   GDestroyNotify        destroy;
 892 } PageSetupResponseData;
 893
 894 static void
 895 page_setup_data_free (gpointer data)
 896 {
 897   PageSetupResponseData *rdata = data;
 898
 899   if (rdata->page_setup)
 900     g_object_unref (rdata->page_setup);
 901
 902   g_free (rdata);
 903 }
 904
 905 static void
 906 handle_page_setup_response (GtkWidget *dialog,
 907                             gint       response,
 908                             gpointer   data)
 909 {
 910   GtkPageSetupUnixDialog *psd;
 911   PageSetupResponseData *rdata = data;
 912
 913   psd = GTK_PAGE_SETUP_UNIX_DIALOG (dialog);
 914   if (response == GTK_RESPONSE_OK)
 915     rdata->page_setup = gtk_page_setup_unix_dialog_get_page_setup (psd);
 916
 917   gtk_widget_destroy (dialog);
 918
 919   if (rdata->done_cb)
 920     rdata->done_cb (rdata->page_setup, rdata->data);
 921
 922   if (rdata->destroy)
 923     rdata->destroy (rdata);
 924 }
 925
 926 static GtkWidget *
 927 get_page_setup_dialog (GtkWindow        *parent,
 928                        GtkPageSetup     *page_setup,
 929                        GtkPrintSettings *settings)
 930 {
 931   GtkWidget *dialog;
 932
 933   dialog = gtk_page_setup_unix_dialog_new (NULL, parent);
 934   if (page_setup)
 935     gtk_page_setup_unix_dialog_set_page_setup (GTK_PAGE_SETUP_UNIX_DIALOG (dialog),
 936                                                page_setup);
 937   gtk_page_setup_unix_dialog_set_print_settings (GTK_PAGE_SETUP_UNIX_DIALOG (dialog),
 938                                                  settings);
 939
 940   return dialog;
 941 }
 942
 943 /**
 944  * gtk_print_run_page_setup_dialog:
 945  * @parent: (allow-none): transient parent
 946  * @page_setup: (allow-none): an existing #GtkPageSetup
 947  * @settings: a #GtkPrintSettings
 948  *
 949  * Runs a page setup dialog, letting the user modify the values from
 950  * @page_setup. If the user cancels the dialog, the returned #GtkPageSetup
 951  * is identical to the passed in @page_setup, otherwise it contains the
 952  * modifications done in the dialog.
 953  *
 954  * Note that this function may use a recursive mainloop to show the page
 955  * setup dialog. See gtk_print_run_page_setup_dialog_async() if this is
 956  * a problem.
 957  *
 958  * Return value: a new #GtkPageSetup
 959  *
 960  * Since: 2.10
 961  */
 962 GtkPageSetup *
 963 gtk_print_run_page_setup_dialog (GtkWindow        *parent,
 964                                  GtkPageSetup     *page_setup,
 965                                  GtkPrintSettings *settings)
 966 {
 967   GtkWidget *dialog;
 968   gint response;
 969   PageSetupResponseData rdata;
 970
 971   rdata.page_setup = NULL;
 972   rdata.done_cb = NULL;
 973   rdata.data = NULL;
 974   rdata.destroy = NULL;
 975
 976   dialog = get_page_setup_dialog (parent, page_setup, settings);
 977   response = gtk_dialog_run (GTK_DIALOG (dialog));
 978   handle_page_setup_response (dialog, response, &rdata);
 979
 980   if (rdata.page_setup)
 981     return rdata.page_setup;
 982   else if (page_setup)
 983     return gtk_page_setup_copy (page_setup);
 984   else
 985     return gtk_page_setup_new ();
 986 }
 987
 988 /**
 989  * gtk_print_run_page_setup_dialog_async:
 990  * @parent: (allow-none): transient parent, or %NULL
 991  * @page_setup: (allow-none): an existing #GtkPageSetup, or %NULL
 992  * @settings: a #GtkPrintSettings
 993  * @done_cb: a function to call when the user saves the modified page setup
 994  * @data: user data to pass to @done_cb
 995  *
 996  * Runs a page setup dialog, letting the user modify the values from @page_setup.
 997  *
 998  * In contrast to gtk_print_run_page_setup_dialog(), this function  returns after
 999  * showing the page setup dialog on platforms that support this, and calls @done_cb
1000  * from a signal handler for the ::response signal of the dialog.
1001  *
1002  * Since: 2.10
1003  */
1004 void
1005 gtk_print_run_page_setup_dialog_async (GtkWindow            *parent,
1006                                        GtkPageSetup         *page_setup,
1007                                        GtkPrintSettings     *settings,
1008                                        GtkPageSetupDoneFunc  done_cb,
1009                                        gpointer              data)
1010 {
1011   GtkWidget *dialog;
1012   PageSetupResponseData *rdata;
1013
1014   dialog = get_page_setup_dialog (parent, page_setup, settings);
1015   gtk_window_set_modal (GTK_WINDOW (dialog), TRUE);
1016
1017   rdata = g_new (PageSetupResponseData, 1);
1018   rdata->page_setup = NULL;
1019   rdata->done_cb = done_cb;
1020   rdata->data = data;
1021   rdata->destroy = page_setup_data_free;
1022
1023   g_signal_connect (dialog, "response",
1024                     G_CALLBACK (handle_page_setup_response), rdata);
1025
1026   gtk_window_present (GTK_WINDOW (dialog));
1027  }
1028
1029 struct _PrinterFinder
1030 {
1031   gboolean found_printer;
1032   GFunc func;
1033   gpointer data;
1034   gchar *printer_name;
1035   GList *backends;
1036   guint timeout_tag;
1037   GtkPrinter *printer;
1038   GtkPrinter *default_printer;
1039   GtkPrinter *first_printer;
1040 };
1041
1042 static gboolean
1043 find_printer_idle (gpointer data)
1044 {
1045   PrinterFinder *finder = data;
1046   GtkPrinter *printer;
1047
1048   if (finder->printer != NULL)
1049     printer = finder->printer;
1050   else if (finder->default_printer != NULL)
1051     printer = finder->default_printer;
1052   else if (finder->first_printer != NULL)
1053     printer = finder->first_printer;
1054   else
1055     printer = NULL;
1056
1057   finder->func (printer, finder->data);
1058
1059   printer_finder_free (finder);
1060
1061   return FALSE;
1062 }
1063
1064 static void
1065 printer_added_cb (GtkPrintBackend *backend,
1066                   GtkPrinter      *printer,
1067                   PrinterFinder   *finder)
1068 {
1069   if (finder->found_printer)
1070     return;
1071
1072   /* FIXME this skips "Print to PDF" - is this intentional ? */
1073   if (gtk_printer_is_virtual (printer))
1074     return;
1075
1076   if (finder->printer_name != NULL &&
1077       strcmp (gtk_printer_get_name (printer), finder->printer_name) == 0)
1078     {
1079       finder->printer = g_object_ref (printer);
1080       finder->found_printer = TRUE;
1081     }
1082   else if (finder->default_printer == NULL &&
1083            gtk_printer_is_default (printer))
1084     {
1085       finder->default_printer = g_object_ref (printer);
1086       if (finder->printer_name == NULL)
1087         finder->found_printer = TRUE;
1088     }
1089   else
1090     if (finder->first_printer == NULL)
1091       finder->first_printer = g_object_ref (printer);
1092
1093   if (finder->found_printer)
1094     g_idle_add (find_printer_idle, finder);
1095 }
1096
1097 static void
1098 printer_list_done_cb (GtkPrintBackend *backend,
1099                       PrinterFinder   *finder)
1100 {
1101   finder->backends = g_list_remove (finder->backends, backend);
1102
1103   g_signal_handlers_disconnect_by_func (backend, printer_added_cb, finder);
1104   g_signal_handlers_disconnect_by_func (backend, printer_list_done_cb, finder);
1105
1106   gtk_print_backend_destroy (backend);
1107   g_object_unref (backend);
1108
1109   if (finder->backends == NULL && !finder->found_printer)
1110     g_idle_add (find_printer_idle, finder);
1111 }
1112
1113 static void
1114 find_printer_init (PrinterFinder   *finder,
1115                    GtkPrintBackend *backend)
1116 {
1117   GList *list;
1118   GList *node;
1119
1120   list = gtk_print_backend_get_printer_list (backend);
1121
1122   node = list;
1123   while (node != NULL)
1124     {
1125       printer_added_cb (backend, node->data, finder);
1126       node = node->next;
1127
1128       if (finder->found_printer)
1129         break;
1130     }
1131
1132   g_list_free (list);
1133
1134   if (gtk_print_backend_printer_list_is_done (backend))
1135     {
1136       finder->backends = g_list_remove (finder->backends, backend);
1137       gtk_print_backend_destroy (backend);
1138       g_object_unref (backend);
1139     }
1140   else
1141     {
1142       g_signal_connect (backend, "printer-added",
1143                         (GCallback) printer_added_cb,
1144                         finder);
1145       g_signal_connect (backend, "printer-list-done",
1146                         (GCallback) printer_list_done_cb,
1147                         finder);
1148     }
1149
1150 }
1151
1152 static void
1153 printer_finder_free (PrinterFinder *finder)
1154 {
1155   GList *l;
1156
1157   g_free (finder->printer_name);
1158
1159   if (finder->printer)
1160     g_object_unref (finder->printer);
1161
1162   if (finder->default_printer)
1163     g_object_unref (finder->default_printer);
1164
1165   if (finder->first_printer)
1166     g_object_unref (finder->first_printer);
1167
1168   for (l = finder->backends; l != NULL; l = l->next)
1169     {
1170       GtkPrintBackend *backend = l->data;
1171       g_signal_handlers_disconnect_by_func (backend, printer_added_cb, finder);
1172       g_signal_handlers_disconnect_by_func (backend, printer_list_done_cb, finder);
1173       gtk_print_backend_destroy (backend);
1174       g_object_unref (backend);
1175     }
1176
1177   g_list_free (finder->backends);
1178
1179   g_free (finder);
1180 }
1181
1182 static void
1183 find_printer (const gchar *printer,
1184               GFunc        func,
1185               gpointer     data)
1186 {
1187   GList *node, *next;
1188   PrinterFinder *finder;
1189
1190   finder = g_new0 (PrinterFinder, 1);
1191
1192   finder->printer_name = g_strdup (printer);
1193   finder->func = func;
1194   finder->data = data;
1195
1196   finder->backends = NULL;
1197   if (g_module_supported ())
1198     finder->backends = gtk_print_backend_load_modules ();
1199
1200   for (node = finder->backends; !finder->found_printer && node != NULL; node = next)
1201     {
1202       next = node->next;
1203       find_printer_init (finder, GTK_PRINT_BACKEND (node->data));
1204     }
1205
1206   if (finder->backends == NULL && !finder->found_printer)
1207     g_idle_add (find_printer_idle, finder);
1208 }
1209
1210 #define __GTK_PRINT_OPERATION_UNIX_C__
1211 #include "gtkaliasdef.c"