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

   1 /* GTK - The GIMP Toolkit
   2  * gtkprintoperation-unix.c: Print Operation Details for Unix and Unix like platforms
   3  * Copyright (C) 2006, Red Hat, Inc.
   4  *
   5  * This library is free software; you can redistribute it and/or
   6  * modify it under the terms of the GNU Lesser General Public
   7  * License as published by the Free Software Foundation; either
   8  * version 2 of the License, or (at your option) any later version.
   9  *
  10  * This library is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13  * Lesser General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU Lesser General Public
  16  * License along with this library; if not, write to the
  17  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  18  * Boston, MA 02111-1307, USA.
  19  */
  20
  21 #include "config.h"
  22 #ifdef HAVE_UNISTD_H
  23 #include <unistd.h>
  24 #endif
  25 #include <sys/types.h>
  26 #include <sys/stat.h>
  27 #include <string.h>
  28 #include <errno.h>
  29 #include <stdlib.h>
  30 #include <fcntl.h>
  31
  32 #include "gtkprintoperation-private.h"
  33 #include "gtkmarshal.h"
  34 #include "gtkmessagedialog.h"
  35
  36 #include <cairo-pdf.h>
  37 #include <cairo-ps.h>
  38 #include "gtkprintunixdialog.h"
  39 #include "gtkpagesetupunixdialog.h"
  40 #include "gtkprintbackend.h"
  41 #include "gtkprinter.h"
  42 #include "gtkprinter-private.h"
  43 #include "gtkprintjob.h"
  44 #include "gtklabel.h"
  45 #include "gtkalias.h"
  46 #include "gtkintl.h"
  47
  48 typedef struct
  49 {
  50   GtkWindow *parent;        /* just in case we need to throw error dialogs */
  51   GMainLoop *loop;
  52   gboolean data_sent;
  53
  54   /* Real printing (not preview) */
  55   GtkPrintJob *job;         /* the job we are sending to the printer */
  56   cairo_surface_t *surface;
  57   gulong job_status_changed_tag;
  58
  59
  60 } GtkPrintOperationUnix;
  61
  62 typedef struct _PrinterFinder PrinterFinder;
  63
  64 static void printer_finder_free (PrinterFinder *finder);
  65 static void find_printer        (const gchar   *printer,
  66                                  GFunc          func,
  67                                  gpointer       data);
  68
  69 static void
  70 unix_start_page (GtkPrintOperation *op,
  71                  GtkPrintContext   *print_context,
  72                  GtkPageSetup      *page_setup)
  73 {
  74   GtkPrintOperationUnix *op_unix;
  75   GtkPaperSize *paper_size;
  76   cairo_surface_type_t type;
  77   gdouble w, h;
  78
  79   op_unix = op->priv->platform_data;
  80
  81   paper_size = gtk_page_setup_get_paper_size (page_setup);
  82
  83   w = gtk_paper_size_get_width (paper_size, GTK_UNIT_POINTS);
  84   h = gtk_paper_size_get_height (paper_size, GTK_UNIT_POINTS);
  85
  86   type = cairo_surface_get_type (op_unix->surface);
  87
  88   if (type == CAIRO_SURFACE_TYPE_PS)
  89     cairo_ps_surface_set_size (op_unix->surface, w, h);
  90   else if (type == CAIRO_SURFACE_TYPE_PDF)
  91     cairo_pdf_surface_set_size (op_unix->surface, w, h);
  92 }
  93
  94 static void
  95 unix_end_page (GtkPrintOperation *op,
  96                GtkPrintContext   *print_context)
  97 {
  98   cairo_t *cr;
  99
 100   cr = gtk_print_context_get_cairo_context (print_context);
 101   cairo_show_page (cr);
 102 }
 103
 104 static void
 105 op_unix_free (GtkPrintOperationUnix *op_unix)
 106 {
 107   if (op_unix->job)
 108     {
 109       g_signal_handler_disconnect (op_unix->job,
 110                                    op_unix->job_status_changed_tag);
 111       g_object_unref (op_unix->job);
 112     }
 113
 114   g_free (op_unix);
 115 }
 116
 117 static gchar *
 118 shell_command_substitute_file (const gchar *cmd,
 119                                const gchar *filename)
 120 {
 121   const gchar *inptr, *start;
 122   gchar *result;
 123   GString *final;
 124
 125   g_return_val_if_fail (cmd != NULL, NULL);
 126   g_return_val_if_fail (filename != NULL, NULL);
 127
 128   result = NULL;
 129   final = g_string_new (NULL);
 130
 131   start = inptr = cmd;
 132
 133   while ((inptr = strchr (inptr, '%')) != NULL)
 134     {
 135       g_string_append_len (final, start, inptr - start);
 136       inptr++;
 137       switch (*inptr)
 138         {
 139           case 'f':
 140             g_string_append (final, filename ? filename : "");
 141             break;
 142
 143           case '%':
 144             g_string_append_c (final, '%');
 145             break;
 146
 147           default:
 148             g_string_append_c (final, '%');
 149             if (*inptr)
 150               g_string_append_c (final, *inptr);
 151             break;
 152         }
 153       if (*inptr)
 154         inptr++;
 155       start = inptr;
 156     }
 157   g_string_append (final, start);
 158
 159   result = final->str;
 160
 161   g_string_free (final, FALSE);
 162
 163   return result;
 164 }
 165
 166 void
 167 _gtk_print_operation_platform_backend_launch_preview (GtkPrintOperation *op,
 168                                                       cairo_surface_t   *surface,
 169                                                       GtkWindow         *parent,
 170                                                       const gchar       *filename)
 171 {
 172   gint argc;
 173   gchar **argv;
 174   gchar *cmd;
 175   gchar *preview_cmd;
 176   GtkSettings *settings;
 177   gchar *quoted_filename;
 178   GdkScreen *screen;
 179   GError *error = NULL;
 180
 181   cairo_surface_destroy (surface);
 182
 183   settings = gtk_settings_get_default ();
 184   g_object_get (settings, "gtk-print-preview-command", &preview_cmd, NULL);
 185
 186   quoted_filename = g_shell_quote (filename);
 187   cmd = shell_command_substitute_file (preview_cmd, quoted_filename);
 188   g_shell_parse_argv (cmd, &argc, &argv, &error);
 189
 190   if (error != NULL)
 191     goto out;
 192
 193   if (parent)
 194     screen = gtk_window_get_screen (parent);
 195   else
 196     screen = gdk_screen_get_default ();
 197
 198   gdk_spawn_on_screen (screen, NULL, argv, NULL, G_SPAWN_SEARCH_PATH, NULL, NULL, NULL, &error);
 199
 200  out:
 201   if (error != NULL)
 202     {
 203       GtkWidget *edialog;
 204       edialog = gtk_message_dialog_new (parent,
 205                                         GTK_DIALOG_DESTROY_WITH_PARENT,
 206                                         GTK_MESSAGE_ERROR,
 207                                         GTK_BUTTONS_CLOSE,
 208                                         _("Error launching preview") /* FIXME better text */);
 209       gtk_message_dialog_format_secondary_text (GTK_MESSAGE_DIALOG (edialog),
 210                                                 "%s", error->message);
 211       gtk_window_set_modal (GTK_WINDOW (edialog), TRUE);
 212       g_signal_connect (edialog, "response",
 213                         G_CALLBACK (gtk_widget_destroy), NULL);
 214
 215       gtk_window_present (GTK_WINDOW (edialog));
 216
 217       g_error_free (error);
 218    }
 219
 220   g_free (cmd);
 221   g_free (quoted_filename);
 222   g_free (preview_cmd);
 223   g_strfreev (argv);
 224 }
 225
 226 static void
 227 unix_finish_send  (GtkPrintJob *job,
 228                    gpointer     user_data,
 229                    GError      *error)
 230 {
 231   GtkPrintOperationUnix *op_unix;
 232
 233   op_unix = (GtkPrintOperationUnix *) user_data;
 234
 235   if (error != NULL)
 236     {
 237       GtkWidget *edialog;
 238       edialog = gtk_message_dialog_new (op_unix->parent,
 239                                         GTK_DIALOG_DESTROY_WITH_PARENT,
 240                                         GTK_MESSAGE_ERROR,
 241                                         GTK_BUTTONS_CLOSE,
 242                                         _("Error printing") /* FIXME better text */);
 243       gtk_message_dialog_format_secondary_text (GTK_MESSAGE_DIALOG (edialog),
 244                                                 "%s", error->message);
 245       gtk_window_set_modal (GTK_WINDOW (edialog), TRUE);
 246       g_signal_connect (edialog, "response",
 247                         G_CALLBACK (gtk_widget_destroy), NULL);
 248
 249       gtk_window_present (GTK_WINDOW (edialog));
 250     }
 251
 252   op_unix->data_sent = TRUE;
 253
 254   if (op_unix->loop)
 255     g_main_loop_quit (op_unix->loop);
 256 }
 257
 258 static void
 259 unix_end_run (GtkPrintOperation *op,
 260               gboolean           wait,
 261               gboolean           cancelled)
 262 {
 263   GtkPrintOperationUnix *op_unix = op->priv->platform_data;
 264
 265   cairo_surface_finish (op_unix->surface);
 266
 267   if (cancelled)
 268     return;
 269
 270   if (wait)
 271     op_unix->loop = g_main_loop_new (NULL, FALSE);
 272
 273   /* TODO: Check for error */
 274   if (op_unix->job != NULL)
 275     gtk_print_job_send (op_unix->job,
 276                         unix_finish_send,
 277                         op_unix, NULL,
 278                         NULL);
 279
 280   if (wait)
 281     {
 282       if (!op_unix->data_sent)
 283         {
 284           GDK_THREADS_LEAVE ();
 285           g_main_loop_run (op_unix->loop);
 286           GDK_THREADS_ENTER ();
 287         }
 288       g_main_loop_unref (op_unix->loop);
 289     }
 290 }
 291
 292 static void
 293 job_status_changed_cb (GtkPrintJob       *job,
 294                        GtkPrintOperation *op)
 295 {
 296   _gtk_print_operation_set_status (op, gtk_print_job_get_status (job), NULL);
 297 }
 298
 299
 300 static GtkWidget *
 301 get_print_dialog (GtkPrintOperation *op,
 302                   GtkWindow         *parent)
 303 {
 304   GtkPrintOperationPrivate *priv = op->priv;
 305   GtkWidget *pd, *label;
 306   GtkPageSetup *page_setup;
 307   const gchar *custom_tab_label;
 308
 309   pd = gtk_print_unix_dialog_new (NULL, parent);
 310
 311   gtk_print_unix_dialog_set_manual_capabilities (GTK_PRINT_UNIX_DIALOG (pd),
 312                                                  GTK_PRINT_CAPABILITY_PAGE_SET |
 313                                                  GTK_PRINT_CAPABILITY_COPIES |
 314                                                  GTK_PRINT_CAPABILITY_COLLATE |
 315                                                  GTK_PRINT_CAPABILITY_REVERSE |
 316                                                  GTK_PRINT_CAPABILITY_SCALE);
 317
 318   if (priv->print_settings)
 319     gtk_print_unix_dialog_set_settings (GTK_PRINT_UNIX_DIALOG (pd),
 320                                         priv->print_settings);
 321   if (priv->default_page_setup)
 322     page_setup = gtk_page_setup_copy (priv->default_page_setup);
 323   else
 324     page_setup = gtk_page_setup_new ();
 325
 326   gtk_print_unix_dialog_set_page_setup (GTK_PRINT_UNIX_DIALOG (pd),
 327                                         page_setup);
 328   g_object_unref (page_setup);
 329
 330   g_signal_emit_by_name (op, "create-custom-widget",
 331                          &priv->custom_widget);
 332
 333   if (priv->custom_widget)
 334     {
 335       custom_tab_label = priv->custom_tab_label;
 336
 337       if (custom_tab_label == NULL)
 338         {
 339           custom_tab_label = g_get_application_name ();
 340           if (custom_tab_label == NULL)
 341             custom_tab_label = _("Application");
 342         }
 343
 344       label = gtk_label_new (custom_tab_label);
 345
 346       gtk_print_unix_dialog_add_custom_tab (GTK_PRINT_UNIX_DIALOG (pd),
 347                                             priv->custom_widget, label);
 348     }
 349
 350   return pd;
 351 }
 352
 353 typedef struct
 354 {
 355   GtkPrintOperation           *op;
 356   gboolean                     do_print;
 357   gboolean                     do_preview;
 358   GtkPrintOperationResult      result;
 359   GtkPrintOperationPrintFunc   print_cb;
 360   GDestroyNotify               destroy;
 361   GtkWindow                   *parent;
 362   GMainLoop                   *loop;
 363 } PrintResponseData;
 364
 365 static void
 366 print_response_data_free (gpointer data)
 367 {
 368   PrintResponseData *rdata = data;
 369
 370   g_object_unref (rdata->op);
 371   g_free (rdata);
 372 }
 373
 374 static void
 375 finish_print (PrintResponseData *rdata,
 376               GtkPrinter        *printer,
 377               GtkPageSetup      *page_setup,
 378               GtkPrintSettings  *settings)
 379 {
 380   GtkPrintOperation *op = rdata->op;
 381   GtkPrintOperationPrivate *priv = op->priv;
 382   GtkPrintJob *job;
 383
 384   if (rdata->do_print)
 385     {
 386       gtk_print_operation_set_print_settings (op, settings);
 387       priv->print_context = _gtk_print_context_new (op);
 388       _gtk_print_context_set_page_setup (priv->print_context, page_setup);
 389
 390       if (!rdata->do_preview)
 391         {
 392           GtkPrintOperationUnix *op_unix;
 393           cairo_t *cr;
 394
 395           op_unix = g_new0 (GtkPrintOperationUnix, 1);
 396           priv->platform_data = op_unix;
 397           priv->free_platform_data = (GDestroyNotify) op_unix_free;
 398           op_unix->parent = rdata->parent;
 399
 400           priv->start_page = unix_start_page;
 401           priv->end_page = unix_end_page;
 402           priv->end_run = unix_end_run;
 403
 404           job = gtk_print_job_new (priv->job_name, printer, settings, page_setup);
 405           op_unix->job = job;
 406           gtk_print_job_set_track_print_status (job, priv->track_print_status);
 407
 408           op_unix->surface = gtk_print_job_get_surface (job, &priv->error);
 409           if (op_unix->surface == NULL)
 410             {
 411               rdata->result = GTK_PRINT_OPERATION_RESULT_ERROR;
 412               rdata->do_print = FALSE;
 413               goto out;
 414             }
 415
 416           cr = cairo_create (op_unix->surface);
 417           gtk_print_context_set_cairo_context (priv->print_context, cr, 72, 72);
 418           cairo_destroy (cr);
 419
 420           _gtk_print_operation_set_status (op, gtk_print_job_get_status (job), NULL);
 421
 422           op_unix->job_status_changed_tag =
 423             g_signal_connect (job, "status-changed",
 424                               G_CALLBACK (job_status_changed_cb), op);
 425
 426           priv->print_pages = job->print_pages;
 427           priv->page_ranges = job->page_ranges;
 428           priv->num_page_ranges = job->num_page_ranges;
 429
 430           priv->manual_num_copies = job->num_copies;
 431           priv->manual_collation = job->collate;
 432           priv->manual_reverse = job->reverse;
 433           priv->manual_page_set = job->page_set;
 434           priv->manual_scale = job->scale;
 435           priv->manual_orientation = job->rotate_to_orientation;
 436         }
 437     }
 438  out:
 439   if (rdata->print_cb)
 440     rdata->print_cb (op, rdata->parent, rdata->do_print, rdata->result);
 441
 442   if (rdata->destroy)
 443     rdata->destroy (rdata);
 444 }
 445
 446 static void
 447 handle_print_response (GtkWidget *dialog,
 448                        gint       response,
 449                        gpointer   data)
 450 {
 451   GtkPrintUnixDialog *pd = GTK_PRINT_UNIX_DIALOG (dialog);
 452   PrintResponseData *rdata = data;
 453   GtkPrintSettings *settings = NULL;
 454   GtkPageSetup *page_setup = NULL;
 455   GtkPrinter *printer = NULL;
 456
 457   if (response == GTK_RESPONSE_OK)
 458     {
 459       printer = gtk_print_unix_dialog_get_selected_printer (GTK_PRINT_UNIX_DIALOG (pd));
 460
 461       rdata->result = GTK_PRINT_OPERATION_RESULT_APPLY;
 462       rdata->do_preview = FALSE;
 463       if (printer != NULL)
 464         rdata->do_print = TRUE;
 465     }
 466   else if (response == GTK_RESPONSE_APPLY)
 467     {
 468       /* print preview */
 469       rdata->result = GTK_PRINT_OPERATION_RESULT_APPLY;
 470       rdata->do_preview = TRUE;
 471       rdata->do_print = TRUE;
 472     }
 473
 474   if (rdata->do_print)
 475     {
 476       settings = gtk_print_unix_dialog_get_settings (GTK_PRINT_UNIX_DIALOG (pd));
 477       page_setup = gtk_print_unix_dialog_get_page_setup (GTK_PRINT_UNIX_DIALOG (pd));
 478
 479       g_signal_emit_by_name (rdata->op, "custom-widget-apply", rdata->op->priv->custom_widget);
 480     }
 481
 482   finish_print (rdata, printer, page_setup, settings);
 483
 484   if (settings)
 485     g_object_unref (settings);
 486
 487   gtk_widget_destroy (GTK_WIDGET (pd));
 488
 489 }
 490
 491
 492 static void
 493 found_printer (GtkPrinter        *printer,
 494                PrintResponseData *rdata)
 495 {
 496   GtkPrintOperation *op = rdata->op;
 497   GtkPrintOperationPrivate *priv = op->priv;
 498   GtkPrintSettings *settings = NULL;
 499   GtkPageSetup *page_setup = NULL;
 500
 501   if (rdata->loop)
 502     g_main_loop_quit (rdata->loop);
 503
 504   if (printer != NULL)
 505     {
 506       rdata->result = GTK_PRINT_OPERATION_RESULT_APPLY;
 507
 508       rdata->do_print = TRUE;
 509
 510       if (priv->print_settings)
 511         settings = gtk_print_settings_copy (priv->print_settings);
 512       else
 513         settings = gtk_print_settings_new ();
 514
 515       gtk_print_settings_set_printer (settings,
 516                                       gtk_printer_get_name (printer));
 517
 518       if (priv->default_page_setup)
 519         page_setup = gtk_page_setup_copy (priv->default_page_setup);
 520       else
 521         page_setup = gtk_page_setup_new ();
 522   }
 523
 524   finish_print (rdata, printer, page_setup, settings);
 525
 526   if (settings)
 527     g_object_unref (settings);
 528
 529   if (page_setup)
 530     g_object_unref (page_setup);
 531 }
 532
 533 void
 534 _gtk_print_operation_platform_backend_run_dialog_async (GtkPrintOperation          *op,
 535                                                         gboolean                    show_dialog,
 536                                                         GtkWindow                  *parent,
 537                                                         GtkPrintOperationPrintFunc  print_cb)
 538 {
 539   GtkWidget *pd;
 540   PrintResponseData *rdata;
 541   const gchar *printer_name;
 542
 543   rdata = g_new (PrintResponseData, 1);
 544   rdata->op = g_object_ref (op);
 545   rdata->do_print = FALSE;
 546   rdata->result = GTK_PRINT_OPERATION_RESULT_CANCEL;
 547   rdata->print_cb = print_cb;
 548   rdata->parent = parent;
 549   rdata->loop = NULL;
 550   rdata->destroy = print_response_data_free;
 551
 552   if (show_dialog)
 553     {
 554       pd = get_print_dialog (op, parent);
 555       gtk_window_set_modal (GTK_WINDOW (pd), TRUE);
 556
 557       g_signal_connect (pd, "response",
 558                         G_CALLBACK (handle_print_response), rdata);
 559
 560       gtk_window_present (GTK_WINDOW (pd));
 561     }
 562   else
 563     {
 564       printer_name = NULL;
 565       if (op->priv->print_settings)
 566         printer_name = gtk_print_settings_get_printer (op->priv->print_settings);
 567
 568       find_printer (printer_name, (GFunc) found_printer, rdata);
 569     }
 570 }
 571
 572 cairo_surface_t *
 573 _gtk_print_operation_platform_backend_create_preview_surface (GtkPrintOperation *op,
 574                                                               GtkPageSetup      *page_setup,
 575                                                               gdouble           *dpi_x,
 576                                                               gdouble           *dpi_y,
 577                                                               gchar            **target)
 578 {
 579   gchar *tmp_dir, *dir_template, *preview_filename;
 580   GtkPaperSize *paper_size;
 581   gdouble w, h;
 582
 583   dir_template = g_build_filename (g_get_tmp_dir (), "print-preview-XXXXXX", NULL);
 584
 585   /* use temp dirs because apps like evince need to have extensions
 586    * to determine the mime type
 587    */
 588   tmp_dir = mkdtemp(dir_template);
 589   preview_filename = g_build_filename (tmp_dir,
 590                                       "Print Preview.pdf",
 591                                       NULL);
 592   g_free (dir_template);
 593   *target = preview_filename;
 594
 595   paper_size = gtk_page_setup_get_paper_size (page_setup);
 596   w = gtk_paper_size_get_width (paper_size, GTK_UNIT_POINTS);
 597   h = gtk_paper_size_get_height (paper_size, GTK_UNIT_POINTS);
 598
 599   *dpi_x = *dpi_y = 72;
 600   return cairo_pdf_surface_create (preview_filename, w, h);
 601 }
 602
 603 void
 604 _gtk_print_operation_platform_backend_preview_start_page (GtkPrintOperation *op,
 605                                                           cairo_surface_t   *surface,
 606                                                           cairo_t           *cr)
 607 {
 608 }
 609
 610 void
 611 _gtk_print_operation_platform_backend_preview_end_page (GtkPrintOperation *op,
 612                                                         cairo_surface_t   *surface,
 613                                                         cairo_t           *cr)
 614 {
 615   cairo_show_page (cr);
 616 }
 617
 618 void
 619 _gtk_print_operation_platform_backend_resize_preview_surface (GtkPrintOperation *op,
 620                                                               GtkPageSetup      *page_setup,
 621                                                               cairo_surface_t   *surface)
 622 {
 623   GtkPaperSize *paper_size;
 624   gdouble w, h;
 625
 626   paper_size = gtk_page_setup_get_paper_size (page_setup);
 627   w = gtk_paper_size_get_width (paper_size, GTK_UNIT_POINTS);
 628   h = gtk_paper_size_get_height (paper_size, GTK_UNIT_POINTS);
 629   cairo_pdf_surface_set_size (surface, w, h);
 630 }
 631
 632
 633 GtkPrintOperationResult
 634 _gtk_print_operation_platform_backend_run_dialog (GtkPrintOperation *op,
 635                                                   gboolean           show_dialog,
 636                                                   GtkWindow         *parent,
 637                                                   gboolean          *do_print)
 638  {
 639   GtkWidget *pd;
 640   PrintResponseData rdata;
 641   gint response;
 642   const gchar *printer_name;
 643
 644   rdata.op = op;
 645   rdata.do_print = FALSE;
 646   rdata.result = GTK_PRINT_OPERATION_RESULT_CANCEL;
 647   rdata.print_cb = NULL;
 648   rdata.destroy = NULL;
 649   rdata.parent = parent;
 650   rdata.loop = NULL;
 651
 652   if (show_dialog)
 653     {
 654       pd = get_print_dialog (op, parent);
 655
 656       response = gtk_dialog_run (GTK_DIALOG (pd));
 657       handle_print_response (pd, response, &rdata);
 658     }
 659   else
 660     {
 661       printer_name = NULL;
 662       if (op->priv->print_settings)
 663         printer_name = gtk_print_settings_get_printer (op->priv->print_settings);
 664
 665       rdata.loop = g_main_loop_new (NULL, FALSE);
 666       find_printer (printer_name,
 667                     (GFunc) found_printer, &rdata);
 668
 669       GDK_THREADS_LEAVE ();
 670       g_main_loop_run (rdata.loop);
 671       GDK_THREADS_ENTER ();
 672
 673       g_main_loop_unref (rdata.loop);
 674       rdata.loop = NULL;
 675     }
 676
 677   *do_print = rdata.do_print;
 678
 679   return rdata.result;
 680 }
 681
 682
 683 typedef struct
 684 {
 685   GtkPageSetup         *page_setup;
 686   GtkPageSetupDoneFunc  done_cb;
 687   gpointer              data;
 688   GDestroyNotify        destroy;
 689 } PageSetupResponseData;
 690
 691 static void
 692 page_setup_data_free (gpointer data)
 693 {
 694   PageSetupResponseData *rdata = data;
 695
 696   if (rdata->page_setup)
 697     g_object_unref (rdata->page_setup);
 698
 699   g_free (rdata);
 700 }
 701
 702 static void
 703 handle_page_setup_response (GtkWidget *dialog,
 704                             gint       response,
 705                             gpointer   data)
 706 {
 707   GtkPageSetupUnixDialog *psd;
 708   PageSetupResponseData *rdata = data;
 709
 710   psd = GTK_PAGE_SETUP_UNIX_DIALOG (dialog);
 711   if (response == GTK_RESPONSE_OK)
 712     rdata->page_setup = gtk_page_setup_unix_dialog_get_page_setup (psd);
 713
 714   gtk_widget_destroy (dialog);
 715
 716   if (rdata->done_cb)
 717     rdata->done_cb (rdata->page_setup, rdata->data);
 718
 719   if (rdata->destroy)
 720     rdata->destroy (rdata);
 721 }
 722
 723 static GtkWidget *
 724 get_page_setup_dialog (GtkWindow        *parent,
 725                        GtkPageSetup     *page_setup,
 726                        GtkPrintSettings *settings)
 727 {
 728   GtkWidget *dialog;
 729
 730   dialog = gtk_page_setup_unix_dialog_new (NULL, parent);
 731   if (page_setup)
 732     gtk_page_setup_unix_dialog_set_page_setup (GTK_PAGE_SETUP_UNIX_DIALOG (dialog),
 733                                                page_setup);
 734   gtk_page_setup_unix_dialog_set_print_settings (GTK_PAGE_SETUP_UNIX_DIALOG (dialog),
 735                                                  settings);
 736
 737   return dialog;
 738 }
 739
 740 /**
 741  * gtk_print_run_page_setup_dialog:
 742  * @parent: transient parent, or %NULL
 743  * @page_setup: an existing #GtkPageSetup, or %NULL
 744  * @settings: a #GtkPrintSettings
 745  *
 746  * Runs a page setup dialog, letting the user modify the values from
 747  * @page_setup. If the user cancels the dialog, the returned #GtkPageSetup
 748  * is identical to the passed in @page_setup, otherwise it contains the
 749  * modifications done in the dialog.
 750  *
 751  * Note that this function may use a recursive mainloop to show the page
 752  * setup dialog. See gtk_print_run_page_setup_dialog_async() if this is
 753  * a problem.
 754  *
 755  * Return value: a new #GtkPageSetup
 756  *
 757  * Since: 2.10
 758  */
 759 GtkPageSetup *
 760 gtk_print_run_page_setup_dialog (GtkWindow        *parent,
 761                                  GtkPageSetup     *page_setup,
 762                                  GtkPrintSettings *settings)
 763 {
 764   GtkWidget *dialog;
 765   gint response;
 766   PageSetupResponseData rdata;
 767
 768   rdata.page_setup = NULL;
 769   rdata.done_cb = NULL;
 770   rdata.data = NULL;
 771   rdata.destroy = NULL;
 772
 773   dialog = get_page_setup_dialog (parent, page_setup, settings);
 774   response = gtk_dialog_run (GTK_DIALOG (dialog));
 775   handle_page_setup_response (dialog, response, &rdata);
 776
 777   if (rdata.page_setup)
 778     return rdata.page_setup;
 779   else if (page_setup)
 780     return gtk_page_setup_copy (page_setup);
 781   else
 782     return gtk_page_setup_new ();
 783 }
 784
 785 /**
 786  * gtk_print_run_page_setup_dialog_async:
 787  * @parent: transient parent, or %NULL
 788  * @page_setup: an existing #GtkPageSetup, or %NULL
 789  * @settings: a #GtkPrintSettings
 790  * @done_cb: a function to call when the user saves the modified page setup
 791  * @data: user data to pass to @done_cb
 792  *
 793  * Runs a page setup dialog, letting the user modify the values from @page_setup.
 794  *
 795  * In contrast to gtk_print_run_page_setup_dialog(), this function  returns after
 796  * showing the page setup dialog on platforms that support this, and calls @done_cb
 797  * from a signal handler for the ::response signal of the dialog.
 798  *
 799  * Since: 2.10
 800  */
 801 void
 802 gtk_print_run_page_setup_dialog_async (GtkWindow            *parent,
 803                                        GtkPageSetup         *page_setup,
 804                                        GtkPrintSettings     *settings,
 805                                        GtkPageSetupDoneFunc  done_cb,
 806                                        gpointer              data)
 807 {
 808   GtkWidget *dialog;
 809   PageSetupResponseData *rdata;
 810
 811   dialog = get_page_setup_dialog (parent, page_setup, settings);
 812   gtk_window_set_modal (GTK_WINDOW (dialog), TRUE);
 813
 814   rdata = g_new (PageSetupResponseData, 1);
 815   rdata->page_setup = NULL;
 816   rdata->done_cb = done_cb;
 817   rdata->data = data;
 818   rdata->destroy = page_setup_data_free;
 819
 820   g_signal_connect (dialog, "response",
 821                     G_CALLBACK (handle_page_setup_response), rdata);
 822
 823   gtk_window_present (GTK_WINDOW (dialog));
 824  }
 825
 826 struct _PrinterFinder
 827 {
 828   gboolean found_printer;
 829   GFunc func;
 830   gpointer data;
 831   gchar *printer_name;
 832   GList *backends;
 833   guint timeout_tag;
 834   GtkPrinter *printer;
 835   GtkPrinter *default_printer;
 836   GtkPrinter *first_printer;
 837 };
 838
 839 static gboolean
 840 find_printer_idle (gpointer data)
 841 {
 842   PrinterFinder *finder = data;
 843   GtkPrinter *printer;
 844
 845   if (finder->printer != NULL)
 846     printer = finder->printer;
 847   else if (finder->default_printer != NULL)
 848     printer = finder->default_printer;
 849   else if (finder->first_printer != NULL)
 850     printer = finder->first_printer;
 851   else
 852     printer = NULL;
 853
 854   finder->func (printer, finder->data);
 855
 856   printer_finder_free (finder);
 857
 858   return FALSE;
 859 }
 860
 861 static void
 862 printer_added_cb (GtkPrintBackend *backend,
 863                   GtkPrinter      *printer,
 864                   PrinterFinder   *finder)
 865 {
 866   if (finder->found_printer)
 867     return;
 868
 869   /* FIXME this skips "Print to PDF" - is this intentional ? */
 870   if (gtk_printer_is_virtual (printer))
 871     return;
 872
 873   if (finder->printer_name != NULL &&
 874       strcmp (gtk_printer_get_name (printer), finder->printer_name) == 0)
 875     {
 876       finder->printer = g_object_ref (printer);
 877       finder->found_printer = TRUE;
 878     }
 879   else if (finder->default_printer == NULL &&
 880            gtk_printer_is_default (printer))
 881     {
 882       finder->default_printer = g_object_ref (printer);
 883       if (finder->printer_name == NULL)
 884         finder->found_printer = TRUE;
 885     }
 886   else
 887     if (finder->first_printer == NULL)
 888       finder->first_printer = g_object_ref (printer);
 889
 890   if (finder->found_printer)
 891     g_idle_add (find_printer_idle, finder);
 892 }
 893
 894 static void
 895 printer_list_done_cb (GtkPrintBackend *backend,
 896                       PrinterFinder   *finder)
 897 {
 898   finder->backends = g_list_remove (finder->backends, backend);
 899
 900   g_signal_handlers_disconnect_by_func (backend, printer_added_cb, finder);
 901   g_signal_handlers_disconnect_by_func (backend, printer_list_done_cb, finder);
 902
 903   gtk_print_backend_destroy (backend);
 904   g_object_unref (backend);
 905
 906   if (finder->backends == NULL && !finder->found_printer)
 907     g_idle_add (find_printer_idle, finder);
 908 }
 909
 910 static void
 911 find_printer_init (PrinterFinder   *finder,
 912                    GtkPrintBackend *backend)
 913 {
 914   GList *list;
 915   GList *node;
 916
 917   list = gtk_print_backend_get_printer_list (backend);
 918
 919   node = list;
 920   while (node != NULL)
 921     {
 922       printer_added_cb (backend, node->data, finder);
 923       node = node->next;
 924
 925       if (finder->found_printer)
 926         break;
 927     }
 928
 929   g_list_free (list);
 930
 931   if (gtk_print_backend_printer_list_is_done (backend))
 932     {
 933       finder->backends = g_list_remove (finder->backends, backend);
 934       gtk_print_backend_destroy (backend);
 935       g_object_unref (backend);
 936     }
 937   else
 938     {
 939       g_signal_connect (backend, "printer-added",
 940                         (GCallback) printer_added_cb,
 941                         finder);
 942       g_signal_connect (backend, "printer-list-done",
 943                         (GCallback) printer_list_done_cb,
 944                         finder);
 945     }
 946
 947 }
 948
 949 static void
 950 printer_finder_free (PrinterFinder *finder)
 951 {
 952   GList *l;
 953
 954   g_free (finder->printer_name);
 955
 956   if (finder->printer)
 957     g_object_unref (finder->printer);
 958
 959   if (finder->default_printer)
 960     g_object_unref (finder->default_printer);
 961
 962   if (finder->first_printer)
 963     g_object_unref (finder->first_printer);
 964
 965   for (l = finder->backends; l != NULL; l = l->next)
 966     {
 967       GtkPrintBackend *backend = l->data;
 968       g_signal_handlers_disconnect_by_func (backend, printer_added_cb, finder);
 969       g_signal_handlers_disconnect_by_func (backend, printer_list_done_cb, finder);
 970       gtk_print_backend_destroy (backend);
 971       g_object_unref (backend);
 972     }
 973
 974   g_list_free (finder->backends);
 975
 976   g_free (finder);
 977 }
 978
 979 static void
 980 find_printer (const gchar *printer,
 981               GFunc        func,
 982               gpointer     data)
 983 {
 984   GList *node, *next;
 985   PrinterFinder *finder;
 986
 987   finder = g_new0 (PrinterFinder, 1);
 988
 989   finder->printer_name = g_strdup (printer);
 990   finder->func = func;
 991   finder->data = data;
 992
 993   finder->backends = NULL;
 994   if (g_module_supported ())
 995     finder->backends = gtk_print_backend_load_modules ();
 996
 997   for (node = finder->backends; !finder->found_printer && node != NULL; node = next)
 998     {
 999       next = node->next;
1000       find_printer_init (finder, GTK_PRINT_BACKEND (node->data));
1001     }
1002
1003   if (finder->backends == NULL && !finder->found_printer)
1004     g_idle_add (find_printer_idle, finder);
1005 }
1006
1007 #define __GTK_PRINT_OPERATION_UNIX_C__
1008 #include "gtkaliasdef.c"