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   int 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).
 393  *
 394  * Returns: %FALSE if an error occurred
 395  *
 396  * Since: 2.10
 397  **/
 398 gboolean
 399 gtk_print_job_set_source_file (GtkPrintJob *job,
 400                                const gchar *filename,
 401                                GError     **error)
 402 {
 403   GtkPrintJobPrivate *priv;
 404
 405   g_return_val_if_fail (GTK_IS_PRINT_JOB (job), FALSE);
 406
 407   priv = job->priv;
 408
 409   priv->spool_file_fd = g_open (filename, O_RDONLY|O_BINARY);
 410   if (priv->spool_file_fd < 0)
 411     {
 412       gchar *display_filename = g_filename_display_name (filename);
 413       int save_errno = errno;
 414
 415       g_set_error (error,
 416                    G_FILE_ERROR,
 417                    g_file_error_from_errno (save_errno),
 418                    _("Failed to open file '%s': %s"),
 419                    display_filename,
 420                    g_strerror (save_errno));
 421
 422       g_free (display_filename);
 423
 424       return FALSE;
 425     }
 426     return TRUE;
 427 }
 428
 429 /**
 430  * gtk_print_job_get_surface:
 431  * @job: a #GtkPrintJob
 432  * @error: return location for errors, or %NULL
 433  *
 434  * Gets a cairo surface onto which the pages of
 435  * the print job should be rendered.
 436  *
 437  * Return value: the cairo surface of @job
 438  *
 439  * Since: 2.10
 440  **/
 441 cairo_surface_t *
 442 gtk_print_job_get_surface (GtkPrintJob  *job,
 443                            GError      **error)
 444 {
 445   GtkPrintJobPrivate *priv;
 446   gchar *filename;
 447   gdouble width, height;
 448   GtkPaperSize *paper_size;
 449
 450   g_return_val_if_fail (GTK_IS_PRINT_JOB (job), NULL);
 451
 452   priv = job->priv;
 453
 454   if (priv->surface)
 455     return priv->surface;
 456
 457   g_return_val_if_fail (priv->spool_file_fd == -1, NULL);
 458
 459   priv->spool_file_fd = g_file_open_tmp ("gtkprint_XXXXXX",
 460                                                     &filename,
 461                                                     error);
 462   if (priv->spool_file_fd == -1)
 463     return NULL;
 464
 465   fchmod (priv->spool_file_fd, S_IRUSR | S_IWUSR);
 466   unlink (filename);
 467
 468   paper_size = gtk_page_setup_get_paper_size (priv->page_setup);
 469   width = gtk_paper_size_get_width (paper_size, GTK_UNIT_POINTS);
 470   height = gtk_paper_size_get_height (paper_size, GTK_UNIT_POINTS);
 471
 472   priv->surface = _gtk_printer_create_cairo_surface (priv->printer,
 473                                                           width, height,
 474                                                           priv->spool_file_fd);
 475
 476   return priv->surface;
 477 }
 478
 479 /**
 480  * gtk_print_job_set_track_print_status:
 481  * @job: a #GtkPrintJob
 482  * @track_status: %TRUE to track status after printing
 483  *
 484  * If track_status is %TRUE, the print job will try to continue report
 485  * on the status of the print job in the printer queues and printer. This
 486  * can allow your application to show things like "out of paper" issues,
 487  * and when the print job actually reaches the printer.
 488  *
 489  * This function is often implemented using some form of polling, so it should
 490  * not be enabled unless needed.
 491  *
 492  * Since: 2.10
 493  */
 494 void
 495 gtk_print_job_set_track_print_status (GtkPrintJob *job,
 496                                       gboolean track_status)
 497 {
 498   GtkPrintJobPrivate *priv;
 499
 500   g_return_if_fail (GTK_IS_PRINT_JOB (job));
 501
 502   priv = job->priv;
 503
 504   priv->track_print_status = track_status;
 505 }
 506
 507 /**
 508  * gtk_print_job_get_track_print_status:
 509  * @job: a #GtkPrintJob
 510  *
 511  * Returns wheter jobs will be tracked after printing.
 512  * For details, see gtk_print_job_set_track_print_status().
 513  *
 514  * Return value: %TRUE if print job status will be reported after printing
 515  *
 516  * Since: 2.10
 517  */
 518 gboolean
 519 gtk_print_job_get_track_print_status (GtkPrintJob *job)
 520 {
 521   GtkPrintJobPrivate *priv;
 522
 523   g_return_val_if_fail (GTK_IS_PRINT_JOB (job), FALSE);
 524
 525   priv = job->priv;
 526
 527   return priv->track_print_status;
 528 }
 529
 530 static void
 531 gtk_print_job_set_property (GObject      *object,
 532                             guint         prop_id,
 533                             const GValue *value,
 534                             GParamSpec   *pspec)
 535
 536 {
 537   GtkPrintJob *job = GTK_PRINT_JOB (object);
 538   GtkPrintJobPrivate *priv = job->priv;
 539   GtkPrintSettings *settings;
 540
 541   switch (prop_id)
 542     {
 543     case GTK_PRINT_JOB_PROP_TITLE:
 544       priv->title = g_value_dup_string (value);
 545       break;
 546
 547     case GTK_PRINT_JOB_PROP_PRINTER:
 548       priv->printer = GTK_PRINTER (g_value_dup_object (value));
 549       priv->printer_set = TRUE;
 550       priv->backend = g_object_ref (gtk_printer_get_backend (priv->printer));
 551       break;
 552
 553     case GTK_PRINT_JOB_PROP_PAGE_SETUP:
 554       priv->page_setup = GTK_PAGE_SETUP (g_value_dup_object (value));
 555       priv->page_setup_set = TRUE;
 556       break;
 557
 558     case GTK_PRINT_JOB_PROP_SETTINGS:
 559       /* We save a copy of the settings since we modify
 560        * if when preparing the printer job. */
 561       settings = GTK_PRINT_SETTINGS (g_value_get_object (value));
 562       priv->settings = gtk_print_settings_copy (settings);
 563       priv->settings_set = TRUE;
 564       break;
 565
 566     default:
 567       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 568       break;
 569     }
 570 }
 571
 572 static void
 573 gtk_print_job_get_property (GObject    *object,
 574                             guint       prop_id,
 575                             GValue     *value,
 576                             GParamSpec *pspec)
 577 {
 578   GtkPrintJob *job = GTK_PRINT_JOB (object);
 579   GtkPrintJobPrivate *priv = job->priv;
 580
 581   switch (prop_id)
 582     {
 583     case GTK_PRINT_JOB_PROP_TITLE:
 584       g_value_set_string (value, priv->title);
 585       break;
 586     case GTK_PRINT_JOB_PROP_PRINTER:
 587       g_value_set_object (value, priv->printer);
 588       break;
 589     case GTK_PRINT_JOB_PROP_SETTINGS:
 590       g_value_set_object (value, priv->settings);
 591       break;
 592     case GTK_PRINT_JOB_PROP_PAGE_SETUP:
 593       g_value_set_object (value, priv->page_setup);
 594       break;
 595     default:
 596       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 597       break;
 598     }
 599 }
 600
 601 /**
 602  * gtk_print_job_send:
 603  * @job: a GtkPrintJob
 604  * @callback: function to call when the job completes
 605  * @user_data: user data that gets passed to @callback
 606  * @dnotify: destroy notify for @user_data
 607  * @error: return location for errors, or %NULL
 608  *
 609  * Sends the print job off to the printer.
 610  *
 611  * Return value: %FALSE if an error occurred
 612  *
 613  * Since: 2.10
 614  **/
 615 gboolean
 616 gtk_print_job_send (GtkPrintJob             *job,
 617                     GtkPrintJobCompleteFunc  callback,
 618                     gpointer                 user_data,
 619                     GDestroyNotify           dnotify,
 620                     GError                 **error)
 621 {
 622   GtkPrintJobPrivate *priv;
 623
 624   g_return_val_if_fail (GTK_IS_PRINT_JOB (job), FALSE);
 625
 626   priv = job->priv;
 627   g_return_val_if_fail (priv->spool_file_fd > 0, FALSE);
 628
 629   gtk_print_job_set_status (job, GTK_PRINT_STATUS_SENDING_DATA);
 630   lseek (priv->spool_file_fd, 0, SEEK_SET);
 631   gtk_print_backend_print_stream (priv->backend,
 632                                   job,
 633                                   priv->spool_file_fd,
 634                                   callback,
 635                                   user_data,
 636                                   dnotify);
 637
 638   return TRUE;
 639 }
 640
 641 #define __GTK_PRINT_JOB_C__
 642 #include "gtkaliasdef.c"