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   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 = gtk_print_job_get_pages (job);
 581           priv->page_ranges = gtk_print_job_get_page_ranges (job, &priv->num_page_ranges);
 582           priv->manual_num_copies = gtk_print_job_get_num_copies (job);
 583           priv->manual_collation = gtk_print_job_get_collate (job);
 584           priv->manual_reverse = gtk_print_job_get_reverse (job);
 585           priv->manual_page_set = gtk_print_job_get_page_set (job);
 586           priv->manual_scale = gtk_print_job_get_scale (job);
 587           priv->manual_orientation = gtk_print_job_get_rotate (job);
 588           priv->manual_number_up = gtk_print_job_get_n_up (job);
 589           priv->manual_number_up_layout = gtk_print_job_get_n_up_layout (job);
 590         }
 591     }
 592  out:
 593   if (rdata->print_cb)
 594     rdata->print_cb (op, rdata->parent, rdata->do_print, rdata->result);
 595
 596   if (rdata->destroy)
 597     rdata->destroy (rdata);
 598 }
 599
 600 static void
 601 handle_print_response (GtkWidget *dialog,
 602                        gint       response,
 603                        gpointer   data)
 604 {
 605   GtkPrintUnixDialog *pd = GTK_PRINT_UNIX_DIALOG (dialog);
 606   PrintResponseData *rdata = data;
 607   GtkPrintSettings *settings = NULL;
 608   GtkPageSetup *page_setup = NULL;
 609   GtkPrinter *printer = NULL;
 610   gboolean page_setup_set = FALSE;
 611
 612   if (response == GTK_RESPONSE_OK)
 613     {
 614       printer = gtk_print_unix_dialog_get_selected_printer (GTK_PRINT_UNIX_DIALOG (pd));
 615
 616       rdata->result = GTK_PRINT_OPERATION_RESULT_APPLY;
 617       rdata->do_preview = FALSE;
 618       if (printer != NULL)
 619         rdata->do_print = TRUE;
 620     }
 621   else if (response == GTK_RESPONSE_APPLY)
 622     {
 623       /* print preview */
 624       rdata->result = GTK_PRINT_OPERATION_RESULT_APPLY;
 625       rdata->do_preview = TRUE;
 626       rdata->do_print = TRUE;
 627
 628       rdata->op->priv->action = GTK_PRINT_OPERATION_ACTION_PREVIEW;
 629     }
 630
 631   if (rdata->do_print)
 632     {
 633       settings = gtk_print_unix_dialog_get_settings (GTK_PRINT_UNIX_DIALOG (pd));
 634       page_setup = gtk_print_unix_dialog_get_page_setup (GTK_PRINT_UNIX_DIALOG (pd));
 635       page_setup_set = gtk_print_unix_dialog_get_page_setup_set (GTK_PRINT_UNIX_DIALOG (pd));
 636
 637       g_signal_emit_by_name (rdata->op, "custom-widget-apply", rdata->op->priv->custom_widget);
 638     }
 639
 640   finish_print (rdata, printer, page_setup, settings, page_setup_set);
 641
 642   if (settings)
 643     g_object_unref (settings);
 644
 645   gtk_widget_destroy (GTK_WIDGET (pd));
 646
 647 }
 648
 649
 650 static void
 651 found_printer (GtkPrinter        *printer,
 652                PrintResponseData *rdata)
 653 {
 654   GtkPrintOperation *op = rdata->op;
 655   GtkPrintOperationPrivate *priv = op->priv;
 656   GtkPrintSettings *settings = NULL;
 657   GtkPageSetup *page_setup = NULL;
 658
 659   if (rdata->loop)
 660     g_main_loop_quit (rdata->loop);
 661
 662   if (printer != NULL)
 663     {
 664       rdata->result = GTK_PRINT_OPERATION_RESULT_APPLY;
 665
 666       rdata->do_print = TRUE;
 667
 668       if (priv->print_settings)
 669         settings = gtk_print_settings_copy (priv->print_settings);
 670       else
 671         settings = gtk_print_settings_new ();
 672
 673       gtk_print_settings_set_printer (settings,
 674                                       gtk_printer_get_name (printer));
 675
 676       if (priv->default_page_setup)
 677         page_setup = gtk_page_setup_copy (priv->default_page_setup);
 678       else
 679         page_setup = gtk_page_setup_new ();
 680   }
 681
 682   finish_print (rdata, printer, page_setup, settings, FALSE);
 683
 684   if (settings)
 685     g_object_unref (settings);
 686
 687   if (page_setup)
 688     g_object_unref (page_setup);
 689 }
 690
 691 void
 692 _gtk_print_operation_platform_backend_run_dialog_async (GtkPrintOperation          *op,
 693                                                         gboolean                    show_dialog,
 694                                                         GtkWindow                  *parent,
 695                                                         GtkPrintOperationPrintFunc  print_cb)
 696 {
 697   GtkWidget *pd;
 698   PrintResponseData *rdata;
 699   const gchar *printer_name;
 700
 701   rdata = g_new (PrintResponseData, 1);
 702   rdata->op = g_object_ref (op);
 703   rdata->do_print = FALSE;
 704   rdata->do_preview = FALSE;
 705   rdata->result = GTK_PRINT_OPERATION_RESULT_CANCEL;
 706   rdata->print_cb = print_cb;
 707   rdata->parent = parent;
 708   rdata->loop = NULL;
 709   rdata->destroy = print_response_data_free;
 710
 711   if (show_dialog)
 712     {
 713       pd = get_print_dialog (op, parent);
 714       gtk_window_set_modal (GTK_WINDOW (pd), TRUE);
 715
 716       g_signal_connect (pd, "response",
 717                         G_CALLBACK (handle_print_response), rdata);
 718
 719       gtk_window_present (GTK_WINDOW (pd));
 720     }
 721   else
 722     {
 723       printer_name = NULL;
 724       if (op->priv->print_settings)
 725         printer_name = gtk_print_settings_get_printer (op->priv->print_settings);
 726
 727       find_printer (printer_name, (GFunc) found_printer, rdata);
 728     }
 729 }
 730
 731 static cairo_status_t
 732 write_preview (void                *closure,
 733                const unsigned char *data,
 734                unsigned int         length)
 735 {
 736   gint fd = GPOINTER_TO_INT (closure);
 737   gssize written;
 738
 739   while (length > 0)
 740     {
 741       written = write (fd, data, length);
 742
 743       if (written == -1)
 744         {
 745           if (errno == EAGAIN || errno == EINTR)
 746             continue;
 747
 748           return CAIRO_STATUS_WRITE_ERROR;
 749         }
 750
 751       data += written;
 752       length -= written;
 753     }
 754
 755   return CAIRO_STATUS_SUCCESS;
 756 }
 757
 758 static void
 759 close_preview (void *data)
 760 {
 761   gint fd = GPOINTER_TO_INT (data);
 762
 763   close (fd);
 764 }
 765
 766 cairo_surface_t *
 767 _gtk_print_operation_platform_backend_create_preview_surface (GtkPrintOperation *op,
 768                                                               GtkPageSetup      *page_setup,
 769                                                               gdouble           *dpi_x,
 770                                                               gdouble           *dpi_y,
 771                                                               gchar            **target)
 772 {
 773   gchar *filename;
 774   gint fd;
 775   GtkPaperSize *paper_size;
 776   gdouble w, h;
 777   cairo_surface_t *surface;
 778   static cairo_user_data_key_t key;
 779
 780   filename = g_build_filename (g_get_tmp_dir (), "previewXXXXXX.pdf", NULL);
 781   fd = g_mkstemp (filename);
 782
 783   if (fd < 0)
 784     {
 785       g_free (filename);
 786       return NULL;
 787     }
 788
 789   *target = filename;
 790
 791   paper_size = gtk_page_setup_get_paper_size (page_setup);
 792   w = gtk_paper_size_get_width (paper_size, GTK_UNIT_POINTS);
 793   h = gtk_paper_size_get_height (paper_size, GTK_UNIT_POINTS);
 794
 795   *dpi_x = *dpi_y = 72;
 796   surface = cairo_pdf_surface_create_for_stream (write_preview, GINT_TO_POINTER (fd), w, h);
 797
 798   cairo_surface_set_user_data (surface, &key, GINT_TO_POINTER (fd), close_preview);
 799
 800   return surface;
 801 }
 802
 803 void
 804 _gtk_print_operation_platform_backend_preview_start_page (GtkPrintOperation *op,
 805                                                           cairo_surface_t   *surface,
 806                                                           cairo_t           *cr)
 807 {
 808 }
 809
 810 void
 811 _gtk_print_operation_platform_backend_preview_end_page (GtkPrintOperation *op,
 812                                                         cairo_surface_t   *surface,
 813                                                         cairo_t           *cr)
 814 {
 815   cairo_show_page (cr);
 816 }
 817
 818 void
 819 _gtk_print_operation_platform_backend_resize_preview_surface (GtkPrintOperation *op,
 820                                                               GtkPageSetup      *page_setup,
 821                                                               cairo_surface_t   *surface)
 822 {
 823   GtkPaperSize *paper_size;
 824   gdouble w, h;
 825
 826   paper_size = gtk_page_setup_get_paper_size (page_setup);
 827   w = gtk_paper_size_get_width (paper_size, GTK_UNIT_POINTS);
 828   h = gtk_paper_size_get_height (paper_size, GTK_UNIT_POINTS);
 829   cairo_pdf_surface_set_size (surface, w, h);
 830 }
 831
 832
 833 GtkPrintOperationResult
 834 _gtk_print_operation_platform_backend_run_dialog (GtkPrintOperation *op,
 835                                                   gboolean           show_dialog,
 836                                                   GtkWindow         *parent,
 837                                                   gboolean          *do_print)
 838  {
 839   GtkWidget *pd;
 840   PrintResponseData rdata;
 841   gint response;
 842   const gchar *printer_name;
 843
 844   rdata.op = op;
 845   rdata.do_print = FALSE;
 846   rdata.do_preview = FALSE;
 847   rdata.result = GTK_PRINT_OPERATION_RESULT_CANCEL;
 848   rdata.print_cb = NULL;
 849   rdata.destroy = NULL;
 850   rdata.parent = parent;
 851   rdata.loop = NULL;
 852
 853   if (show_dialog)
 854     {
 855       pd = get_print_dialog (op, parent);
 856
 857       response = gtk_dialog_run (GTK_DIALOG (pd));
 858       handle_print_response (pd, response, &rdata);
 859     }
 860   else
 861     {
 862       printer_name = NULL;
 863       if (op->priv->print_settings)
 864         printer_name = gtk_print_settings_get_printer (op->priv->print_settings);
 865
 866       rdata.loop = g_main_loop_new (NULL, FALSE);
 867       find_printer (printer_name,
 868                     (GFunc) found_printer, &rdata);
 869
 870       GDK_THREADS_LEAVE ();
 871       g_main_loop_run (rdata.loop);
 872       GDK_THREADS_ENTER ();
 873
 874       g_main_loop_unref (rdata.loop);
 875       rdata.loop = NULL;
 876     }
 877
 878   *do_print = rdata.do_print;
 879
 880   return rdata.result;
 881 }
 882
 883
 884 typedef struct
 885 {
 886   GtkPageSetup         *page_setup;
 887   GtkPageSetupDoneFunc  done_cb;
 888   gpointer              data;
 889   GDestroyNotify        destroy;
 890 } PageSetupResponseData;
 891
 892 static void
 893 page_setup_data_free (gpointer data)
 894 {
 895   PageSetupResponseData *rdata = data;
 896
 897   if (rdata->page_setup)
 898     g_object_unref (rdata->page_setup);
 899
 900   g_free (rdata);
 901 }
 902
 903 static void
 904 handle_page_setup_response (GtkWidget *dialog,
 905                             gint       response,
 906                             gpointer   data)
 907 {
 908   GtkPageSetupUnixDialog *psd;
 909   PageSetupResponseData *rdata = data;
 910
 911   psd = GTK_PAGE_SETUP_UNIX_DIALOG (dialog);
 912   if (response == GTK_RESPONSE_OK)
 913     rdata->page_setup = gtk_page_setup_unix_dialog_get_page_setup (psd);
 914
 915   gtk_widget_destroy (dialog);
 916
 917   if (rdata->done_cb)
 918     rdata->done_cb (rdata->page_setup, rdata->data);
 919
 920   if (rdata->destroy)
 921     rdata->destroy (rdata);
 922 }
 923
 924 static GtkWidget *
 925 get_page_setup_dialog (GtkWindow        *parent,
 926                        GtkPageSetup     *page_setup,
 927                        GtkPrintSettings *settings)
 928 {
 929   GtkWidget *dialog;
 930
 931   dialog = gtk_page_setup_unix_dialog_new (NULL, parent);
 932   if (page_setup)
 933     gtk_page_setup_unix_dialog_set_page_setup (GTK_PAGE_SETUP_UNIX_DIALOG (dialog),
 934                                                page_setup);
 935   gtk_page_setup_unix_dialog_set_print_settings (GTK_PAGE_SETUP_UNIX_DIALOG (dialog),
 936                                                  settings);
 937
 938   return dialog;
 939 }
 940
 941 /**
 942  * gtk_print_run_page_setup_dialog:
 943  * @parent: (allow-none): transient parent
 944  * @page_setup: (allow-none): an existing #GtkPageSetup
 945  * @settings: a #GtkPrintSettings
 946  *
 947  * Runs a page setup dialog, letting the user modify the values from
 948  * @page_setup. If the user cancels the dialog, the returned #GtkPageSetup
 949  * is identical to the passed in @page_setup, otherwise it contains the
 950  * modifications done in the dialog.
 951  *
 952  * Note that this function may use a recursive mainloop to show the page
 953  * setup dialog. See gtk_print_run_page_setup_dialog_async() if this is
 954  * a problem.
 955  *
 956  * Return value: a new #GtkPageSetup
 957  *
 958  * Since: 2.10
 959  */
 960 GtkPageSetup *
 961 gtk_print_run_page_setup_dialog (GtkWindow        *parent,
 962                                  GtkPageSetup     *page_setup,
 963                                  GtkPrintSettings *settings)
 964 {
 965   GtkWidget *dialog;
 966   gint response;
 967   PageSetupResponseData rdata;
 968
 969   rdata.page_setup = NULL;
 970   rdata.done_cb = NULL;
 971   rdata.data = NULL;
 972   rdata.destroy = NULL;
 973
 974   dialog = get_page_setup_dialog (parent, page_setup, settings);
 975   response = gtk_dialog_run (GTK_DIALOG (dialog));
 976   handle_page_setup_response (dialog, response, &rdata);
 977
 978   if (rdata.page_setup)
 979     return rdata.page_setup;
 980   else if (page_setup)
 981     return gtk_page_setup_copy (page_setup);
 982   else
 983     return gtk_page_setup_new ();
 984 }
 985
 986 /**
 987  * gtk_print_run_page_setup_dialog_async:
 988  * @parent: (allow-none): transient parent, or %NULL
 989  * @page_setup: (allow-none): an existing #GtkPageSetup, or %NULL
 990  * @settings: a #GtkPrintSettings
 991  * @done_cb: a function to call when the user saves the modified page setup
 992  * @data: user data to pass to @done_cb
 993  *
 994  * Runs a page setup dialog, letting the user modify the values from @page_setup.
 995  *
 996  * In contrast to gtk_print_run_page_setup_dialog(), this function  returns after
 997  * showing the page setup dialog on platforms that support this, and calls @done_cb
 998  * from a signal handler for the ::response signal of the dialog.
 999  *
1000  * Since: 2.10
1001  */
1002 void
1003 gtk_print_run_page_setup_dialog_async (GtkWindow            *parent,
1004                                        GtkPageSetup         *page_setup,
1005                                        GtkPrintSettings     *settings,
1006                                        GtkPageSetupDoneFunc  done_cb,
1007                                        gpointer              data)
1008 {
1009   GtkWidget *dialog;
1010   PageSetupResponseData *rdata;
1011
1012   dialog = get_page_setup_dialog (parent, page_setup, settings);
1013   gtk_window_set_modal (GTK_WINDOW (dialog), TRUE);
1014
1015   rdata = g_new (PageSetupResponseData, 1);
1016   rdata->page_setup = NULL;
1017   rdata->done_cb = done_cb;
1018   rdata->data = data;
1019   rdata->destroy = page_setup_data_free;
1020
1021   g_signal_connect (dialog, "response",
1022                     G_CALLBACK (handle_page_setup_response), rdata);
1023
1024   gtk_window_present (GTK_WINDOW (dialog));
1025  }
1026
1027 struct _PrinterFinder
1028 {
1029   gboolean found_printer;
1030   GFunc func;
1031   gpointer data;
1032   gchar *printer_name;
1033   GList *backends;
1034   guint timeout_tag;
1035   GtkPrinter *printer;
1036   GtkPrinter *default_printer;
1037   GtkPrinter *first_printer;
1038 };
1039
1040 static gboolean
1041 find_printer_idle (gpointer data)
1042 {
1043   PrinterFinder *finder = data;
1044   GtkPrinter *printer;
1045
1046   if (finder->printer != NULL)
1047     printer = finder->printer;
1048   else if (finder->default_printer != NULL)
1049     printer = finder->default_printer;
1050   else if (finder->first_printer != NULL)
1051     printer = finder->first_printer;
1052   else
1053     printer = NULL;
1054
1055   finder->func (printer, finder->data);
1056
1057   printer_finder_free (finder);
1058
1059   return FALSE;
1060 }
1061
1062 static void
1063 printer_added_cb (GtkPrintBackend *backend,
1064                   GtkPrinter      *printer,
1065                   PrinterFinder   *finder)
1066 {
1067   if (finder->found_printer)
1068     return;
1069
1070   /* FIXME this skips "Print to PDF" - is this intentional ? */
1071   if (gtk_printer_is_virtual (printer))
1072     return;
1073
1074   if (finder->printer_name != NULL &&
1075       strcmp (gtk_printer_get_name (printer), finder->printer_name) == 0)
1076     {
1077       finder->printer = g_object_ref (printer);
1078       finder->found_printer = TRUE;
1079     }
1080   else if (finder->default_printer == NULL &&
1081            gtk_printer_is_default (printer))
1082     {
1083       finder->default_printer = g_object_ref (printer);
1084       if (finder->printer_name == NULL)
1085         finder->found_printer = TRUE;
1086     }
1087   else
1088     if (finder->first_printer == NULL)
1089       finder->first_printer = g_object_ref (printer);
1090
1091   if (finder->found_printer)
1092     g_idle_add (find_printer_idle, finder);
1093 }
1094
1095 static void
1096 printer_list_done_cb (GtkPrintBackend *backend,
1097                       PrinterFinder   *finder)
1098 {
1099   finder->backends = g_list_remove (finder->backends, backend);
1100
1101   g_signal_handlers_disconnect_by_func (backend, printer_added_cb, finder);
1102   g_signal_handlers_disconnect_by_func (backend, printer_list_done_cb, finder);
1103
1104   gtk_print_backend_destroy (backend);
1105   g_object_unref (backend);
1106
1107   if (finder->backends == NULL && !finder->found_printer)
1108     g_idle_add (find_printer_idle, finder);
1109 }
1110
1111 static void
1112 find_printer_init (PrinterFinder   *finder,
1113                    GtkPrintBackend *backend)
1114 {
1115   GList *list;
1116   GList *node;
1117
1118   list = gtk_print_backend_get_printer_list (backend);
1119
1120   node = list;
1121   while (node != NULL)
1122     {
1123       printer_added_cb (backend, node->data, finder);
1124       node = node->next;
1125
1126       if (finder->found_printer)
1127         break;
1128     }
1129
1130   g_list_free (list);
1131
1132   if (gtk_print_backend_printer_list_is_done (backend))
1133     {
1134       finder->backends = g_list_remove (finder->backends, backend);
1135       gtk_print_backend_destroy (backend);
1136       g_object_unref (backend);
1137     }
1138   else
1139     {
1140       g_signal_connect (backend, "printer-added",
1141                         (GCallback) printer_added_cb,
1142                         finder);
1143       g_signal_connect (backend, "printer-list-done",
1144                         (GCallback) printer_list_done_cb,
1145                         finder);
1146     }
1147
1148 }
1149
1150 static void
1151 printer_finder_free (PrinterFinder *finder)
1152 {
1153   GList *l;
1154
1155   g_free (finder->printer_name);
1156
1157   if (finder->printer)
1158     g_object_unref (finder->printer);
1159
1160   if (finder->default_printer)
1161     g_object_unref (finder->default_printer);
1162
1163   if (finder->first_printer)
1164     g_object_unref (finder->first_printer);
1165
1166   for (l = finder->backends; l != NULL; l = l->next)
1167     {
1168       GtkPrintBackend *backend = l->data;
1169       g_signal_handlers_disconnect_by_func (backend, printer_added_cb, finder);
1170       g_signal_handlers_disconnect_by_func (backend, printer_list_done_cb, finder);
1171       gtk_print_backend_destroy (backend);
1172       g_object_unref (backend);
1173     }
1174
1175   g_list_free (finder->backends);
1176
1177   g_free (finder);
1178 }
1179
1180 static void
1181 find_printer (const gchar *printer,
1182               GFunc        func,
1183               gpointer     data)
1184 {
1185   GList *node, *next;
1186   PrinterFinder *finder;
1187
1188   finder = g_new0 (PrinterFinder, 1);
1189
1190   finder->printer_name = g_strdup (printer);
1191   finder->func = func;
1192   finder->data = data;
1193
1194   finder->backends = NULL;
1195   if (g_module_supported ())
1196     finder->backends = gtk_print_backend_load_modules ();
1197
1198   for (node = finder->backends; !finder->found_printer && node != NULL; node = next)
1199     {
1200       next = node->next;
1201       find_printer_init (finder, GTK_PRINT_BACKEND (node->data));
1202     }
1203
1204   if (finder->backends == NULL && !finder->found_printer)
1205     g_idle_add (find_printer_idle, finder);
1206 }