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