Pileus Git - ~andy/gtk/blob - gtk/gtkprintjob.c

   1 /* GtkPrintJob
   2  * Copyright (C) 2006 John (J5) Palmieri  <johnp@redhat.com>
   3  *
   4  * This library is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Lesser General Public
   6  * License as published by the Free Software Foundation; either
   7  * version 2 of the License, or (at your option) any later version.
   8  *
   9  * This library is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * Lesser General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Lesser General Public
  15  * License along with this library; if not, write to the
  16  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  17  * Boston, MA 02111-1307, USA.
  18  */
  19
  20 #include "config.h"
  21 #include <stdlib.h>
  22 #include <string.h>
  23 #include <stdio.h>
  24 #include <fcntl.h>
  25 #include <errno.h>
  26 #ifdef HAVE_UNISTD_H
  27 #include <unistd.h>
  28 #endif
  29 #include <sys/types.h>
  30 #include <sys/stat.h>
  31
  32 #include <glib/gstdio.h>
  33 #include "gtkintl.h"
  34 #include "gtkprivate.h"
  35
  36 #include "gtkprintjob.h"
  37 #include "gtkprinter.h"
  38 #include "gtkprinter-private.h"
  39 #include "gtkprintbackend.h"
  40 #include "gtkalias.h"
  41
  42 #ifndef O_BINARY
  43 #define O_BINARY 0
  44 #endif
  45
  46 struct _GtkPrintJobPrivate
  47 {
  48   gchar *title;
  49
  50   gint spool_file_fd;
  51   cairo_surface_t *surface;
  52
  53   GtkPrintStatus status;
  54   GtkPrintBackend *backend;
  55   GtkPrinter *printer;
  56   GtkPrintSettings *settings;
  57   GtkPageSetup *page_setup;
  58
  59   guint printer_set : 1;
  60   guint page_setup_set : 1;
  61   guint settings_set  : 1;
  62   guint track_print_status : 1;
  63 };
  64
  65
  66 #define GTK_PRINT_JOB_GET_PRIVATE(o)  \
  67    (G_TYPE_INSTANCE_GET_PRIVATE ((o), GTK_TYPE_PRINT_JOB, GtkPrintJobPrivate))
  68
  69 static void     gtk_print_job_finalize     (GObject               *object);
  70 static void     gtk_print_job_set_property (GObject               *object,
  71                                             guint                  prop_id,
  72                                             const GValue          *value,
  73                                             GParamSpec            *pspec);
  74 static void     gtk_print_job_get_property (GObject               *object,
  75                                             guint                  prop_id,
  76                                             GValue                *value,
  77                                             GParamSpec            *pspec);
  78 static GObject* gtk_print_job_constructor  (GType                  type,
  79                                             guint                  n_construct_properties,
  80                                             GObjectConstructParam *construct_params);
  81
  82 enum {
  83   STATUS_CHANGED,
  84   LAST_SIGNAL
  85 };
  86
  87 enum {
  88   PROP_0,
  89   GTK_PRINT_JOB_PROP_TITLE,
  90   GTK_PRINT_JOB_PROP_PRINTER,
  91   GTK_PRINT_JOB_PROP_PAGE_SETUP,
  92   GTK_PRINT_JOB_PROP_SETTINGS
  93 };
  94
  95 static guint signals[LAST_SIGNAL] = { 0 };
  96
  97 G_DEFINE_TYPE (GtkPrintJob, gtk_print_job, G_TYPE_OBJECT)
  98
  99 static void
 100 gtk_print_job_class_init (GtkPrintJobClass *class)
 101 {
 102   GObjectClass *object_class;
 103   object_class = (GObjectClass *) class;
 104
 105   object_class->finalize = gtk_print_job_finalize;
 106   object_class->constructor = gtk_print_job_constructor;
 107   object_class->set_property = gtk_print_job_set_property;
 108   object_class->get_property = gtk_print_job_get_property;
 109
 110   g_type_class_add_private (class, sizeof (GtkPrintJobPrivate));
 111
 112   g_object_class_install_property (G_OBJECT_CLASS (class),
 113                                    GTK_PRINT_JOB_PROP_TITLE,
 114                                    g_param_spec_string ("title",
 115                                                         P_("Title"),
 116                                                         P_("Title of the print job"),
 117                                                         NULL,
 118                                                         GTK_PARAM_READWRITE |
 119                                                         G_PARAM_CONSTRUCT_ONLY));
 120
 121   g_object_class_install_property (G_OBJECT_CLASS (class),
 122                                    GTK_PRINT_JOB_PROP_PRINTER,
 123                                    g_param_spec_object ("printer",
 124                                                         P_("Printer"),
 125                                                         P_("Printer to print the job to"),
 126                                                         GTK_TYPE_PRINTER,
 127                                                         GTK_PARAM_READWRITE |
 128                                                         G_PARAM_CONSTRUCT_ONLY));
 129
 130   g_object_class_install_property (G_OBJECT_CLASS (class),
 131                                    GTK_PRINT_JOB_PROP_SETTINGS,
 132                                    g_param_spec_object ("settings",
 133                                                         P_("Settings"),
 134                                                         P_("Printer settings"),
 135                                                         GTK_TYPE_PRINT_SETTINGS,
 136                                                         GTK_PARAM_READWRITE |
 137                                                         G_PARAM_CONSTRUCT_ONLY));
 138
 139   g_object_class_install_property (G_OBJECT_CLASS (class),
 140                                    GTK_PRINT_JOB_PROP_PAGE_SETUP,
 141                                    g_param_spec_object ("page-setup",
 142                                                         P_("Page Setup"),
 143                                                         P_("Page Setup"),
 144                                                         GTK_TYPE_PAGE_SETUP,
 145                                                         GTK_PARAM_READWRITE |
 146                                                         G_PARAM_CONSTRUCT_ONLY));
 147
 148   /**
 149    * GtkPrintJob::status-changed:
 150    * @job: the #GtkPrintJob object on which the signal was emitted
 151    *
 152    * Gets emitted when the status of a job changes. The signal handler
 153    * can use gtk_print_job_get_status() to obtain the new status.
 154    *
 155    * Since: 2.10
 156    */
 157   signals[STATUS_CHANGED] =
 158     g_signal_new (I_("status-changed"),
 159                   G_TYPE_FROM_CLASS (class),
 160                   G_SIGNAL_RUN_LAST,
 161                   G_STRUCT_OFFSET (GtkPrintJobClass, status_changed),
 162                   NULL, NULL,
 163                   g_cclosure_marshal_VOID__VOID,
 164                   G_TYPE_NONE, 0);
 165 }
 166
 167 static void
 168 gtk_print_job_init (GtkPrintJob *job)
 169 {
 170   GtkPrintJobPrivate *priv;
 171
 172   priv = job->priv = GTK_PRINT_JOB_GET_PRIVATE (job);
 173
 174   priv->spool_file_fd = -1;
 175
 176   priv->title = g_strdup ("");
 177   priv->surface = NULL;
 178   priv->backend = NULL;
 179   priv->printer = NULL;
 180
 181   priv->printer_set = FALSE;
 182   priv->settings_set = FALSE;
 183   priv->page_setup_set = FALSE;
 184   priv->status = GTK_PRINT_STATUS_INITIAL;
 185   priv->track_print_status = FALSE;
 186
 187   job->print_pages = GTK_PRINT_PAGES_ALL;
 188   job->page_ranges = NULL;
 189   job->num_page_ranges = 0;
 190   job->collate = FALSE;
 191   job->reverse = FALSE;
 192   job->num_copies = 1;
 193   job->scale = 1.0;
 194   job->page_set = GTK_PAGE_SET_ALL;
 195   job->rotate_to_orientation = FALSE;
 196 }
 197
 198
 199 static GObject*
 200 gtk_print_job_constructor (GType                  type,
 201                            guint                  n_construct_properties,
 202                            GObjectConstructParam *construct_params)
 203 {
 204   GtkPrintJob *job;
 205   GtkPrintJobPrivate *priv;
 206   GObject *object;
 207
 208   object =
 209     G_OBJECT_CLASS (gtk_print_job_parent_class)->constructor (type,
 210                                                               n_construct_properties,
 211                                                               construct_params);
 212
 213   job = GTK_PRINT_JOB (object);
 214
 215   priv = job->priv;
 216   g_assert (priv->printer_set &&
 217             priv->settings_set &&
 218             priv->page_setup_set);
 219
 220   _gtk_printer_prepare_for_print (priv->printer,
 221                                   job,
 222                                   priv->settings,
 223                                   priv->page_setup);
 224
 225   return object;
 226 }
 227
 228
 229 static void
 230 gtk_print_job_finalize (GObject *object)
 231 {
 232   GtkPrintJob *job = GTK_PRINT_JOB (object);
 233   GtkPrintJobPrivate *priv = job->priv;
 234
 235   if (priv->spool_file_fd >= 0)
 236     {
 237       close (priv->spool_file_fd);
 238       priv->spool_file_fd = -1;
 239     }
 240
 241   if (priv->backend)
 242     g_object_unref (priv->backend);
 243
 244   if (priv->printer)
 245     g_object_unref (priv->printer);
 246
 247   if (priv->surface)
 248     cairo_surface_destroy (priv->surface);
 249
 250   if (priv->settings)
 251     g_object_unref (priv->settings);
 252
 253   if (priv->page_setup)
 254     g_object_unref (priv->page_setup);
 255
 256   g_free (job->page_ranges);
 257   job->page_ranges = NULL;
 258
 259   g_free (priv->title);
 260   priv->title = NULL;
 261
 262   G_OBJECT_CLASS (gtk_print_job_parent_class)->finalize (object);
 263 }
 264
 265 /**
 266  * gtk_print_job_new:
 267  * @title: the job title
 268  * @printer: a #GtkPrinter
 269  * @settings: a #GtkPrintSettings
 270  * @page_setup: a #GtkPageSetup
 271  *
 272  * Creates a new #GtkPrintJob.
 273  *
 274  * Return value: a new #GtkPrintJob
 275  *
 276  * Since: 2.10
 277  **/
 278 GtkPrintJob *
 279 gtk_print_job_new (const gchar      *title,
 280                    GtkPrinter       *printer,
 281                    GtkPrintSettings *settings,
 282                    GtkPageSetup     *page_setup)
 283 {
 284   GObject *result;
 285   result = g_object_new (GTK_TYPE_PRINT_JOB,
 286                          "title", title,
 287                          "printer", printer,
 288                          "settings", settings,
 289                          "page-setup", page_setup,
 290                          NULL);
 291   return (GtkPrintJob *) result;
 292 }
 293
 294 /**
 295  * gtk_print_job_get_settings:
 296  * @job: a #GtkPrintJob
 297  *
 298  * Gets the #GtkPrintSettings of the print job.
 299  *
 300  * Return value: the settings of @job
 301  *
 302  * Since: 2.10
 303  */
 304 GtkPrintSettings *
 305 gtk_print_job_get_settings (GtkPrintJob *job)
 306 {
 307   g_return_val_if_fail (GTK_IS_PRINT_JOB (job), NULL);
 308
 309   return job->priv->settings;
 310 }
 311
 312 /**
 313  * gtk_print_job_get_printer:
 314  * @job: a #GtkPrintJob
 315  *
 316  * Gets the #GtkPrinter of the print job.
 317  *
 318  * Return value: the printer of @job
 319  *
 320  * Since: 2.10
 321  */
 322 GtkPrinter *
 323 gtk_print_job_get_printer (GtkPrintJob *job)
 324 {
 325   g_return_val_if_fail (GTK_IS_PRINT_JOB (job), NULL);
 326
 327   return job->priv->printer;
 328 }
 329
 330 /**
 331  * gtk_print_job_get_title:
 332  * @job: a #GtkPrintJob
 333  *
 334  * Gets the job title.
 335  *
 336  * Return value: the title of @job
 337  *
 338  * Since: 2.10
 339  */
 340 G_CONST_RETURN gchar *
 341 gtk_print_job_get_title (GtkPrintJob *job)
 342 {
 343   g_return_val_if_fail (GTK_IS_PRINT_JOB (job), NULL);
 344
 345   return job->priv->title;
 346 }
 347
 348 /**
 349  * gtk_print_job_get_status:
 350  * @job: a #GtkPrintJob
 351  *
 352  * Gets the status of the print job.
 353  *
 354  * Return value: the status of @job
 355  *
 356  * Since: 2.10
 357  */
 358 GtkPrintStatus
 359 gtk_print_job_get_status (GtkPrintJob *job)
 360 {
 361   g_return_val_if_fail (GTK_IS_PRINT_JOB (job), GTK_PRINT_STATUS_FINISHED);
 362
 363   return job->priv->status;
 364 }
 365
 366 void
 367 gtk_print_job_set_status (GtkPrintJob   *job,
 368                           GtkPrintStatus status)
 369 {
 370   GtkPrintJobPrivate *priv;
 371
 372   g_return_if_fail (GTK_IS_PRINT_JOB (job));
 373
 374   priv = job->priv;
 375
 376   if (priv->status == status)
 377     return;
 378
 379   priv->status = status;
 380   g_signal_emit (job, signals[STATUS_CHANGED], 0);
 381 }
 382
 383 /**
 384  * gtk_print_job_set_source_file:
 385  * @job: a #GtkPrintJob
 386  * @filename: the file to be printed
 387  * @error: return location for errors
 388  *
 389  * Make the #GtkPrintJob send an existing document to the
 390  * printing system. The file can be in any format understood
 391  * by the platforms printing system (typically PostScript,
 392  * but on many platforms PDF may work too). See
 393  * gtk_printer_accepts_pdf() and gtk_printer_accepts_ps().
 394  *
 395  * Returns: %FALSE if an error occurred
 396  *
 397  * Since: 2.10
 398  **/
 399 gboolean
 400 gtk_print_job_set_source_file (GtkPrintJob *job,
 401                                const gchar *filename,
 402                                GError     **error)
 403 {
 404   GtkPrintJobPrivate *priv;
 405
 406   g_return_val_if_fail (GTK_IS_PRINT_JOB (job), FALSE);
 407
 408   priv = job->priv;
 409
 410   priv->spool_file_fd = g_open (filename, O_RDONLY|O_BINARY);
 411   if (priv->spool_file_fd < 0)
 412     {
 413       gchar *display_filename = g_filename_display_name (filename);
 414       int save_errno = errno;
 415
 416       g_set_error (error,
 417                    G_FILE_ERROR,
 418                    g_file_error_from_errno (save_errno),
 419                    _("Failed to open file '%s': %s"),
 420                    display_filename,
 421                    g_strerror (save_errno));
 422
 423       g_free (display_filename);
 424
 425       return FALSE;
 426     }
 427     return TRUE;
 428 }
 429
 430 /**
 431  * gtk_print_job_get_surface:
 432  * @job: a #GtkPrintJob
 433  * @error: return location for errors, or %NULL
 434  *
 435  * Gets a cairo surface onto which the pages of
 436  * the print job should be rendered.
 437  *
 438  * Return value: the cairo surface of @job
 439  *
 440  * Since: 2.10
 441  **/
 442 cairo_surface_t *
 443 gtk_print_job_get_surface (GtkPrintJob  *job,
 444                            GError      **error)
 445 {
 446   GtkPrintJobPrivate *priv;
 447   gchar *filename;
 448   gdouble width, height;
 449   GtkPaperSize *paper_size;
 450
 451   g_return_val_if_fail (GTK_IS_PRINT_JOB (job), NULL);
 452
 453   priv = job->priv;
 454
 455   if (priv->surface)
 456     return priv->surface;
 457
 458   g_return_val_if_fail (priv->spool_file_fd == -1, NULL);
 459
 460   priv->spool_file_fd = g_file_open_tmp ("gtkprint_XXXXXX",
 461                                          &filename,
 462                                          error);
 463   if (priv->spool_file_fd == -1)
 464     return NULL;
 465
 466   fchmod (priv->spool_file_fd, S_IRUSR | S_IWUSR);
 467   unlink (filename);
 468
 469   paper_size = gtk_page_setup_get_paper_size (priv->page_setup);
 470   width = gtk_paper_size_get_width (paper_size, GTK_UNIT_POINTS);
 471   height = gtk_paper_size_get_height (paper_size, GTK_UNIT_POINTS);
 472
 473   priv->surface = _gtk_printer_create_cairo_surface (priv->printer,
 474                                                      priv->settings,
 475                                                      width, height,
 476                                                      priv->spool_file_fd);
 477
 478   return priv->surface;
 479 }
 480
 481 /**
 482  * gtk_print_job_set_track_print_status:
 483  * @job: a #GtkPrintJob
 484  * @track_status: %TRUE to track status after printing
 485  *
 486  * If track_status is %TRUE, the print job will try to continue report
 487  * on the status of the print job in the printer queues and printer. This
 488  * can allow your application to show things like "out of paper" issues,
 489  * and when the print job actually reaches the printer.
 490  *
 491  * This function is often implemented using some form of polling, so it should
 492  * not be enabled unless needed.
 493  *
 494  * Since: 2.10
 495  */
 496 void
 497 gtk_print_job_set_track_print_status (GtkPrintJob *job,
 498                                       gboolean     track_status)
 499 {
 500   GtkPrintJobPrivate *priv;
 501
 502   g_return_if_fail (GTK_IS_PRINT_JOB (job));
 503
 504   priv = job->priv;
 505
 506   track_status = track_status != FALSE;
 507
 508   if (priv->track_print_status != track_status)
 509     {
 510       priv->track_print_status = track_status;
 511
 512       g_object_notify (G_OBJECT (job), "track-status");
 513     }
 514 }
 515
 516 /**
 517  * gtk_print_job_get_track_print_status:
 518  * @job: a #GtkPrintJob
 519  *
 520  * Returns wheter jobs will be tracked after printing.
 521  * For details, see gtk_print_job_set_track_print_status().
 522  *
 523  * Return value: %TRUE if print job status will be reported after printing
 524  *
 525  * Since: 2.10
 526  */
 527 gboolean
 528 gtk_print_job_get_track_print_status (GtkPrintJob *job)
 529 {
 530   GtkPrintJobPrivate *priv;
 531
 532   g_return_val_if_fail (GTK_IS_PRINT_JOB (job), FALSE);
 533
 534   priv = job->priv;
 535
 536   return priv->track_print_status;
 537 }
 538
 539 static void
 540 gtk_print_job_set_property (GObject      *object,
 541                             guint         prop_id,
 542                             const GValue *value,
 543                             GParamSpec   *pspec)
 544
 545 {
 546   GtkPrintJob *job = GTK_PRINT_JOB (object);
 547   GtkPrintJobPrivate *priv = job->priv;
 548   GtkPrintSettings *settings;
 549
 550   switch (prop_id)
 551     {
 552     case GTK_PRINT_JOB_PROP_TITLE:
 553       priv->title = g_value_dup_string (value);
 554       break;
 555
 556     case GTK_PRINT_JOB_PROP_PRINTER:
 557       priv->printer = GTK_PRINTER (g_value_dup_object (value));
 558       priv->printer_set = TRUE;
 559       priv->backend = g_object_ref (gtk_printer_get_backend (priv->printer));
 560       break;
 561
 562     case GTK_PRINT_JOB_PROP_PAGE_SETUP:
 563       priv->page_setup = GTK_PAGE_SETUP (g_value_dup_object (value));
 564       priv->page_setup_set = TRUE;
 565       break;
 566
 567     case GTK_PRINT_JOB_PROP_SETTINGS:
 568       /* We save a copy of the settings since we modify
 569        * if when preparing the printer job. */
 570       settings = GTK_PRINT_SETTINGS (g_value_get_object (value));
 571       priv->settings = gtk_print_settings_copy (settings);
 572       priv->settings_set = TRUE;
 573       break;
 574
 575     default:
 576       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 577       break;
 578     }
 579 }
 580
 581 static void
 582 gtk_print_job_get_property (GObject    *object,
 583                             guint       prop_id,
 584                             GValue     *value,
 585                             GParamSpec *pspec)
 586 {
 587   GtkPrintJob *job = GTK_PRINT_JOB (object);
 588   GtkPrintJobPrivate *priv = job->priv;
 589
 590   switch (prop_id)
 591     {
 592     case GTK_PRINT_JOB_PROP_TITLE:
 593       g_value_set_string (value, priv->title);
 594       break;
 595     case GTK_PRINT_JOB_PROP_PRINTER:
 596       g_value_set_object (value, priv->printer);
 597       break;
 598     case GTK_PRINT_JOB_PROP_SETTINGS:
 599       g_value_set_object (value, priv->settings);
 600       break;
 601     case GTK_PRINT_JOB_PROP_PAGE_SETUP:
 602       g_value_set_object (value, priv->page_setup);
 603       break;
 604     default:
 605       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 606       break;
 607     }
 608 }
 609
 610 /**
 611  * gtk_print_job_send:
 612  * @job: a GtkPrintJob
 613  * @callback: function to call when the job completes
 614  * @user_data: user data that gets passed to @callback
 615  * @dnotify: destroy notify for @user_data
 616  * @error: return location for errors, or %NULL
 617  *
 618  * Sends the print job off to the printer.
 619  *
 620  * Return value: %FALSE if an error occurred
 621  *
 622  * Since: 2.10
 623  **/
 624 gboolean
 625 gtk_print_job_send (GtkPrintJob             *job,
 626                     GtkPrintJobCompleteFunc  callback,
 627                     gpointer                 user_data,
 628                     GDestroyNotify           dnotify,
 629                     GError                 **error)
 630 {
 631   GtkPrintJobPrivate *priv;
 632
 633   g_return_val_if_fail (GTK_IS_PRINT_JOB (job), FALSE);
 634
 635   priv = job->priv;
 636   g_return_val_if_fail (priv->spool_file_fd > 0, FALSE);
 637
 638   gtk_print_job_set_status (job, GTK_PRINT_STATUS_SENDING_DATA);
 639   lseek (priv->spool_file_fd, 0, SEEK_SET);
 640   gtk_print_backend_print_stream (priv->backend,
 641                                   job,
 642                                   priv->spool_file_fd,
 643                                   callback,
 644                                   user_data,
 645                                   dnotify);
 646
 647   return TRUE;
 648 }
 649
 650 GType
 651 gtk_print_capabilities_get_type (void)
 652 {
 653   static GType etype = 0;
 654
 655   if (etype == 0)
 656     {
 657       static const GFlagsValue values[] = {
 658         { GTK_PRINT_CAPABILITY_PAGE_SET, "GTK_PRINT_CAPABILITY_PAGE_SET", "page-set" },
 659         { GTK_PRINT_CAPABILITY_COPIES, "GTK_PRINT_CAPABILITY_COPIES", "copies" },
 660         { GTK_PRINT_CAPABILITY_COLLATE, "GTK_PRINT_CAPABILITY_COLLATE", "collate" },
 661         { GTK_PRINT_CAPABILITY_REVERSE, "GTK_PRINT_CAPABILITY_REVERSE", "reverse" },
 662         { GTK_PRINT_CAPABILITY_SCALE, "GTK_PRINT_CAPABILITY_SCALE", "scale" },
 663         { 0, NULL, NULL }
 664       };
 665
 666       etype = g_flags_register_static (I_("GtkPrintCapabilities"), values);
 667     }
 668
 669   return etype;
 670 }
 671
 672
 673 #define __GTK_PRINT_JOB_C__
 674 #include "gtkaliasdef.c"