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