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