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

   1 /* GtkPrinter
   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, see <http://www.gnu.org/licenses/>.
  16  */
  17
  18 #include "config.h"
  19 #include <stdlib.h>
  20 #include <string.h>
  21 #include <stdio.h>
  22
  23 #include "gtkintl.h"
  24 #include "gtkprivate.h"
  25
  26 #include "gtkprinter.h"
  27 #include "gtkprinter-private.h"
  28 #include "gtkprintbackend.h"
  29 #include "gtkprintjob.h"
  30
  31 /**
  32  * SECTION:gtkprinter
  33  * @Short_description: Represents a printer
  34  * @Title: GtkPrinter
  35  *
  36  * A #GtkPrinter object represents a printer. You only need to
  37  * deal directly with printers if you use the non-portable
  38  * #GtkPrintUnixDialog API.
  39  *
  40  * A #GtkPrinter allows to get status information about the printer,
  41  * such as its description, its location, the number of queued jobs,
  42  * etc. Most importantly, a #GtkPrinter object can be used to create
  43  * a #GtkPrintJob object, which lets you print to the printer.
  44  *
  45  * Printing support was added in GTK+ 2.10.
  46  */
  47
  48
  49 static void gtk_printer_finalize     (GObject *object);
  50
  51 struct _GtkPrinterPrivate
  52 {
  53   gchar *name;
  54   gchar *location;
  55   gchar *description;
  56   gchar *icon_name;
  57
  58   guint is_active         : 1;
  59   guint is_paused         : 1;
  60   guint is_accepting_jobs : 1;
  61   guint is_new            : 1;
  62   guint is_virtual        : 1;
  63   guint is_default        : 1;
  64   guint has_details       : 1;
  65   guint accepts_pdf       : 1;
  66   guint accepts_ps        : 1;
  67
  68   gchar *state_message;
  69   gint job_count;
  70
  71   GtkPrintBackend *backend;
  72 };
  73
  74 enum {
  75   DETAILS_ACQUIRED,
  76   LAST_SIGNAL
  77 };
  78
  79 enum {
  80   PROP_0,
  81   PROP_NAME,
  82   PROP_BACKEND,
  83   PROP_IS_VIRTUAL,
  84   PROP_STATE_MESSAGE,
  85   PROP_LOCATION,
  86   PROP_ICON_NAME,
  87   PROP_JOB_COUNT,
  88   PROP_ACCEPTS_PDF,
  89   PROP_ACCEPTS_PS,
  90   PROP_PAUSED,
  91   PROP_ACCEPTING_JOBS
  92 };
  93
  94 static guint signals[LAST_SIGNAL] = { 0 };
  95
  96 static void gtk_printer_set_property (GObject      *object,
  97                                       guint         prop_id,
  98                                       const GValue *value,
  99                                       GParamSpec   *pspec);
 100 static void gtk_printer_get_property (GObject      *object,
 101                                       guint         prop_id,
 102                                       GValue       *value,
 103                                       GParamSpec   *pspec);
 104
 105 G_DEFINE_TYPE (GtkPrinter, gtk_printer, G_TYPE_OBJECT)
 106
 107 static void
 108 gtk_printer_class_init (GtkPrinterClass *class)
 109 {
 110   GObjectClass *object_class;
 111   object_class = (GObjectClass *) class;
 112
 113   object_class->finalize = gtk_printer_finalize;
 114
 115   object_class->set_property = gtk_printer_set_property;
 116   object_class->get_property = gtk_printer_get_property;
 117
 118   g_type_class_add_private (class, sizeof (GtkPrinterPrivate));
 119
 120   g_object_class_install_property (G_OBJECT_CLASS (class),
 121                                    PROP_NAME,
 122                                    g_param_spec_string ("name",
 123                                                         P_("Name"),
 124                                                         P_("Name of the printer"),
 125                                                         "",
 126                                                         GTK_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY));
 127   g_object_class_install_property (G_OBJECT_CLASS (class),
 128                                    PROP_BACKEND,
 129                                    g_param_spec_object ("backend",
 130                                                         P_("Backend"),
 131                                                         P_("Backend for the printer"),
 132                                                         GTK_TYPE_PRINT_BACKEND,
 133                                                         GTK_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY));
 134   g_object_class_install_property (G_OBJECT_CLASS (class),
 135                                    PROP_IS_VIRTUAL,
 136                                    g_param_spec_boolean ("is-virtual",
 137                                                          P_("Is Virtual"),
 138                                                          P_("FALSE if this represents a real hardware printer"),
 139                                                          FALSE,
 140                                                          GTK_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY));
 141   g_object_class_install_property (G_OBJECT_CLASS (class),
 142                                    PROP_ACCEPTS_PDF,
 143                                    g_param_spec_boolean ("accepts-pdf",
 144                                                          P_("Accepts PDF"),
 145                                                          P_("TRUE if this printer can accept PDF"),
 146                                                          FALSE,
 147                                                          GTK_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY));
 148   g_object_class_install_property (G_OBJECT_CLASS (class),
 149                                    PROP_ACCEPTS_PS,
 150                                    g_param_spec_boolean ("accepts-ps",
 151                                                          P_("Accepts PostScript"),
 152                                                          P_("TRUE if this printer can accept PostScript"),
 153                                                          TRUE,
 154                                                          GTK_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY));
 155   g_object_class_install_property (G_OBJECT_CLASS (class),
 156                                    PROP_STATE_MESSAGE,
 157                                    g_param_spec_string ("state-message",
 158                                                         P_("State Message"),
 159                                                         P_("String giving the current state of the printer"),
 160                                                         "",
 161                                                         GTK_PARAM_READABLE));
 162   g_object_class_install_property (G_OBJECT_CLASS (class),
 163                                    PROP_LOCATION,
 164                                    g_param_spec_string ("location",
 165                                                         P_("Location"),
 166                                                         P_("The location of the printer"),
 167                                                         "",
 168                                                         GTK_PARAM_READABLE));
 169   g_object_class_install_property (G_OBJECT_CLASS (class),
 170                                    PROP_ICON_NAME,
 171                                    g_param_spec_string ("icon-name",
 172                                                         P_("Icon Name"),
 173                                                         P_("The icon name to use for the printer"),
 174                                                         "",
 175                                                         GTK_PARAM_READABLE));
 176   g_object_class_install_property (G_OBJECT_CLASS (class),
 177                                    PROP_JOB_COUNT,
 178                                    g_param_spec_int ("job-count",
 179                                                      P_("Job Count"),
 180                                                      P_("Number of jobs queued in the printer"),
 181                                                      0,
 182                                                      G_MAXINT,
 183                                                      0,
 184                                                      GTK_PARAM_READABLE));
 185
 186   /**
 187    * GtkPrinter:paused:
 188    *
 189    * This property is %TRUE if this printer is paused.
 190    * A paused printer still accepts jobs, but it does
 191    * not print them.
 192    *
 193    * Since: 2.14
 194    */
 195   g_object_class_install_property (G_OBJECT_CLASS (class),
 196                                    PROP_PAUSED,
 197                                    g_param_spec_boolean ("paused",
 198                                                          P_("Paused Printer"),
 199                                                          P_("TRUE if this printer is paused"),
 200                                                          FALSE,
 201                                                          GTK_PARAM_READABLE));
 202   /**
 203    * GtkPrinter:accepting-jobs:
 204    *
 205    * This property is %TRUE if the printer is accepting jobs.
 206    *
 207    * Since: 2.14
 208    */
 209   g_object_class_install_property (G_OBJECT_CLASS (class),
 210                                    PROP_ACCEPTING_JOBS,
 211                                    g_param_spec_boolean ("accepting-jobs",
 212                                                          P_("Accepting Jobs"),
 213                                                          P_("TRUE if this printer is accepting new jobs"),
 214                                                          TRUE,
 215                                                          GTK_PARAM_READABLE));
 216
 217   /**
 218    * GtkPrinter::details-acquired:
 219    * @printer: the #GtkPrinter on which the signal is emitted
 220    * @success: %TRUE if the details were successfully acquired
 221    *
 222    * Gets emitted in response to a request for detailed information
 223    * about a printer from the print backend. The @success parameter
 224    * indicates if the information was actually obtained.
 225    *
 226    * Since: 2.10
 227    */
 228   signals[DETAILS_ACQUIRED] =
 229     g_signal_new (I_("details-acquired"),
 230                   G_TYPE_FROM_CLASS (class),
 231                   G_SIGNAL_RUN_LAST,
 232                   G_STRUCT_OFFSET (GtkPrinterClass, details_acquired),
 233                   NULL, NULL,
 234                   g_cclosure_marshal_VOID__BOOLEAN,
 235                   G_TYPE_NONE, 1, G_TYPE_BOOLEAN);
 236 }
 237
 238 static void
 239 gtk_printer_init (GtkPrinter *printer)
 240 {
 241   GtkPrinterPrivate *priv;
 242
 243   priv = printer->priv = G_TYPE_INSTANCE_GET_PRIVATE (printer,
 244                                                       GTK_TYPE_PRINTER,
 245                                                       GtkPrinterPrivate);
 246
 247   priv->name = NULL;
 248   priv->location = NULL;
 249   priv->description = NULL;
 250   priv->icon_name = NULL;
 251
 252   priv->is_active = TRUE;
 253   priv->is_paused = FALSE;
 254   priv->is_accepting_jobs = TRUE;
 255   priv->is_new = TRUE;
 256   priv->has_details = FALSE;
 257   priv->accepts_pdf = FALSE;
 258   priv->accepts_ps = TRUE;
 259
 260   priv->state_message = NULL;
 261   priv->job_count = 0;
 262 }
 263
 264 static void
 265 gtk_printer_finalize (GObject *object)
 266 {
 267   GtkPrinter *printer = GTK_PRINTER (object);
 268   GtkPrinterPrivate *priv = printer->priv;
 269
 270   g_free (priv->name);
 271   g_free (priv->location);
 272   g_free (priv->description);
 273   g_free (priv->state_message);
 274   g_free (priv->icon_name);
 275
 276   if (priv->backend)
 277     g_object_unref (priv->backend);
 278
 279   G_OBJECT_CLASS (gtk_printer_parent_class)->finalize (object);
 280 }
 281
 282 static void
 283 gtk_printer_set_property (GObject         *object,
 284                           guint            prop_id,
 285                           const GValue    *value,
 286                           GParamSpec      *pspec)
 287 {
 288   GtkPrinter *printer = GTK_PRINTER (object);
 289   GtkPrinterPrivate *priv = printer->priv;
 290
 291   switch (prop_id)
 292     {
 293     case PROP_NAME:
 294       priv->name = g_value_dup_string (value);
 295       break;
 296
 297     case PROP_BACKEND:
 298       priv->backend = GTK_PRINT_BACKEND (g_value_dup_object (value));
 299       break;
 300
 301     case PROP_IS_VIRTUAL:
 302       priv->is_virtual = g_value_get_boolean (value);
 303       break;
 304
 305     case PROP_ACCEPTS_PDF:
 306       priv->accepts_pdf = g_value_get_boolean (value);
 307       break;
 308
 309     case PROP_ACCEPTS_PS:
 310       priv->accepts_ps = g_value_get_boolean (value);
 311       break;
 312
 313     default:
 314       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 315       break;
 316     }
 317 }
 318
 319 static void
 320 gtk_printer_get_property (GObject    *object,
 321                           guint       prop_id,
 322                           GValue     *value,
 323                           GParamSpec *pspec)
 324 {
 325   GtkPrinter *printer = GTK_PRINTER (object);
 326   GtkPrinterPrivate *priv = printer->priv;
 327
 328   switch (prop_id)
 329     {
 330     case PROP_NAME:
 331       if (priv->name)
 332         g_value_set_string (value, priv->name);
 333       else
 334         g_value_set_static_string (value, "");
 335       break;
 336     case PROP_BACKEND:
 337       g_value_set_object (value, priv->backend);
 338       break;
 339     case PROP_STATE_MESSAGE:
 340       if (priv->state_message)
 341         g_value_set_string (value, priv->state_message);
 342       else
 343         g_value_set_static_string (value, "");
 344       break;
 345     case PROP_LOCATION:
 346       if (priv->location)
 347         g_value_set_string (value, priv->location);
 348       else
 349         g_value_set_static_string (value, "");
 350       break;
 351     case PROP_ICON_NAME:
 352       if (priv->icon_name)
 353         g_value_set_string (value, priv->icon_name);
 354       else
 355         g_value_set_static_string (value, "");
 356       break;
 357     case PROP_JOB_COUNT:
 358       g_value_set_int (value, priv->job_count);
 359       break;
 360     case PROP_IS_VIRTUAL:
 361       g_value_set_boolean (value, priv->is_virtual);
 362       break;
 363     case PROP_ACCEPTS_PDF:
 364       g_value_set_boolean (value, priv->accepts_pdf);
 365       break;
 366     case PROP_ACCEPTS_PS:
 367       g_value_set_boolean (value, priv->accepts_ps);
 368       break;
 369     case PROP_PAUSED:
 370       g_value_set_boolean (value, priv->is_paused);
 371       break;
 372     case PROP_ACCEPTING_JOBS:
 373       g_value_set_boolean (value, priv->is_accepting_jobs);
 374       break;
 375     default:
 376       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 377       break;
 378     }
 379 }
 380
 381 /**
 382  * gtk_printer_new:
 383  * @name: the name of the printer
 384  * @backend: a #GtkPrintBackend
 385  * @virtual_: whether the printer is virtual
 386  *
 387  * Creates a new #GtkPrinter.
 388  *
 389  * Return value: a new #GtkPrinter
 390  *
 391  * Since: 2.10
 392  **/
 393 GtkPrinter *
 394 gtk_printer_new (const gchar     *name,
 395                  GtkPrintBackend *backend,
 396                  gboolean         virtual_)
 397 {
 398   GObject *result;
 399
 400   result = g_object_new (GTK_TYPE_PRINTER,
 401                          "name", name,
 402                          "backend", backend,
 403                          "is-virtual", virtual_,
 404                          NULL);
 405
 406   return (GtkPrinter *) result;
 407 }
 408
 409 /**
 410  * gtk_printer_get_backend:
 411  * @printer: a #GtkPrinter
 412  *
 413  * Returns the backend of the printer.
 414  *
 415  * Return value: (transfer none): the backend of @printer
 416  *
 417  * Since: 2.10
 418  */
 419 GtkPrintBackend *
 420 gtk_printer_get_backend (GtkPrinter *printer)
 421 {
 422   g_return_val_if_fail (GTK_IS_PRINTER (printer), NULL);
 423
 424   return printer->priv->backend;
 425 }
 426
 427 /**
 428  * gtk_printer_get_name:
 429  * @printer: a #GtkPrinter
 430  *
 431  * Returns the name of the printer.
 432  *
 433  * Return value: the name of @printer
 434  *
 435  * Since: 2.10
 436  */
 437 const gchar *
 438 gtk_printer_get_name (GtkPrinter *printer)
 439 {
 440   g_return_val_if_fail (GTK_IS_PRINTER (printer), NULL);
 441
 442   return printer->priv->name;
 443 }
 444
 445 /**
 446  * gtk_printer_get_description:
 447  * @printer: a #GtkPrinter
 448  *
 449  * Gets the description of the printer.
 450  *
 451  * Return value: the description of @printer
 452  *
 453  * Since: 2.10
 454  */
 455 const gchar *
 456 gtk_printer_get_description (GtkPrinter *printer)
 457 {
 458   g_return_val_if_fail (GTK_IS_PRINTER (printer), NULL);
 459
 460   return printer->priv->description;
 461 }
 462
 463 gboolean
 464 gtk_printer_set_description (GtkPrinter  *printer,
 465                              const gchar *description)
 466 {
 467   GtkPrinterPrivate *priv;
 468
 469   g_return_val_if_fail (GTK_IS_PRINTER (printer), FALSE);
 470
 471   priv = printer->priv;
 472
 473   if (g_strcmp0 (priv->description, description) == 0)
 474     return FALSE;
 475
 476   g_free (priv->description);
 477   priv->description = g_strdup (description);
 478
 479   return TRUE;
 480 }
 481
 482 /**
 483  * gtk_printer_get_state_message:
 484  * @printer: a #GtkPrinter
 485  *
 486  * Returns the state message describing the current state
 487  * of the printer.
 488  *
 489  * Return value: the state message of @printer
 490  *
 491  * Since: 2.10
 492  */
 493 const gchar *
 494 gtk_printer_get_state_message (GtkPrinter *printer)
 495 {
 496   g_return_val_if_fail (GTK_IS_PRINTER (printer), NULL);
 497
 498   return printer->priv->state_message;
 499 }
 500
 501 gboolean
 502 gtk_printer_set_state_message (GtkPrinter  *printer,
 503                                const gchar *message)
 504 {
 505   GtkPrinterPrivate *priv;
 506
 507   g_return_val_if_fail (GTK_IS_PRINTER (printer), FALSE);
 508
 509   priv = printer->priv;
 510
 511   if (g_strcmp0 (priv->state_message, message) == 0)
 512     return FALSE;
 513
 514   g_free (priv->state_message);
 515   priv->state_message = g_strdup (message);
 516   g_object_notify (G_OBJECT (printer), "state-message");
 517
 518   return TRUE;
 519 }
 520
 521 /**
 522  * gtk_printer_get_location:
 523  * @printer: a #GtkPrinter
 524  *
 525  * Returns a description of the location of the printer.
 526  *
 527  * Return value: the location of @printer
 528  *
 529  * Since: 2.10
 530  */
 531 const gchar *
 532 gtk_printer_get_location (GtkPrinter *printer)
 533 {
 534   g_return_val_if_fail (GTK_IS_PRINTER (printer), NULL);
 535
 536   return printer->priv->location;
 537 }
 538
 539 gboolean
 540 gtk_printer_set_location (GtkPrinter  *printer,
 541                           const gchar *location)
 542 {
 543   GtkPrinterPrivate *priv;
 544
 545   g_return_val_if_fail (GTK_IS_PRINTER (printer), FALSE);
 546
 547   priv = printer->priv;
 548
 549   if (g_strcmp0 (priv->location, location) == 0)
 550     return FALSE;
 551
 552   g_free (priv->location);
 553   priv->location = g_strdup (location);
 554   g_object_notify (G_OBJECT (printer), "location");
 555
 556   return TRUE;
 557 }
 558
 559 /**
 560  * gtk_printer_get_icon_name:
 561  * @printer: a #GtkPrinter
 562  *
 563  * Gets the name of the icon to use for the printer.
 564  *
 565  * Return value: the icon name for @printer
 566  *
 567  * Since: 2.10
 568  */
 569 const gchar *
 570 gtk_printer_get_icon_name (GtkPrinter *printer)
 571 {
 572   g_return_val_if_fail (GTK_IS_PRINTER (printer), NULL);
 573
 574   return printer->priv->icon_name;
 575 }
 576
 577 void
 578 gtk_printer_set_icon_name (GtkPrinter  *printer,
 579                            const gchar *icon)
 580 {
 581   GtkPrinterPrivate *priv;
 582
 583   g_return_if_fail (GTK_IS_PRINTER (printer));
 584
 585   priv = printer->priv;
 586
 587   g_free (priv->icon_name);
 588   priv->icon_name = g_strdup (icon);
 589   g_object_notify (G_OBJECT (printer), "icon-name");
 590 }
 591
 592 /**
 593  * gtk_printer_get_job_count:
 594  * @printer: a #GtkPrinter
 595  *
 596  * Gets the number of jobs currently queued on the printer.
 597  *
 598  * Return value: the number of jobs on @printer
 599  *
 600  * Since: 2.10
 601  */
 602 gint
 603 gtk_printer_get_job_count (GtkPrinter *printer)
 604 {
 605   g_return_val_if_fail (GTK_IS_PRINTER (printer), 0);
 606
 607   return printer->priv->job_count;
 608 }
 609
 610 gboolean
 611 gtk_printer_set_job_count (GtkPrinter *printer,
 612                            gint        count)
 613 {
 614   GtkPrinterPrivate *priv;
 615
 616   g_return_val_if_fail (GTK_IS_PRINTER (printer), FALSE);
 617
 618   priv = printer->priv;
 619
 620   if (priv->job_count == count)
 621     return FALSE;
 622
 623   priv->job_count = count;
 624
 625   g_object_notify (G_OBJECT (printer), "job-count");
 626
 627   return TRUE;
 628 }
 629
 630 /**
 631  * gtk_printer_has_details:
 632  * @printer: a #GtkPrinter
 633  *
 634  * Returns whether the printer details are available.
 635  *
 636  * Return value: %TRUE if @printer details are available
 637  *
 638  * Since: 2.12
 639  */
 640 gboolean
 641 gtk_printer_has_details (GtkPrinter *printer)
 642 {
 643   g_return_val_if_fail (GTK_IS_PRINTER (printer), FALSE);
 644
 645   return printer->priv->has_details;
 646 }
 647
 648 void
 649 gtk_printer_set_has_details (GtkPrinter *printer,
 650                              gboolean val)
 651 {
 652   printer->priv->has_details = val;
 653 }
 654
 655 /**
 656  * gtk_printer_is_active:
 657  * @printer: a #GtkPrinter
 658  *
 659  * Returns whether the printer is currently active (i.e.
 660  * accepts new jobs).
 661  *
 662  * Return value: %TRUE if @printer is active
 663  *
 664  * Since: 2.10
 665  */
 666 gboolean
 667 gtk_printer_is_active (GtkPrinter *printer)
 668 {
 669   g_return_val_if_fail (GTK_IS_PRINTER (printer), TRUE);
 670
 671   return printer->priv->is_active;
 672 }
 673
 674 void
 675 gtk_printer_set_is_active (GtkPrinter *printer,
 676                            gboolean val)
 677 {
 678   g_return_if_fail (GTK_IS_PRINTER (printer));
 679
 680   printer->priv->is_active = val;
 681 }
 682
 683 /**
 684  * gtk_printer_is_paused:
 685  * @printer: a #GtkPrinter
 686  *
 687  * Returns whether the printer is currently paused.
 688  * A paused printer still accepts jobs, but it is not
 689  * printing them.
 690  *
 691  * Return value: %TRUE if @printer is paused
 692  *
 693  * Since: 2.14
 694  */
 695 gboolean
 696 gtk_printer_is_paused (GtkPrinter *printer)
 697 {
 698   g_return_val_if_fail (GTK_IS_PRINTER (printer), TRUE);
 699
 700   return printer->priv->is_paused;
 701 }
 702
 703 gboolean
 704 gtk_printer_set_is_paused (GtkPrinter *printer,
 705                            gboolean    val)
 706 {
 707   GtkPrinterPrivate *priv;
 708
 709   g_return_val_if_fail (GTK_IS_PRINTER (printer), FALSE);
 710
 711   priv = printer->priv;
 712
 713   if (val == priv->is_paused)
 714     return FALSE;
 715
 716   priv->is_paused = val;
 717
 718   return TRUE;
 719 }
 720
 721 /**
 722  * gtk_printer_is_accepting_jobs:
 723  * @printer: a #GtkPrinter
 724  *
 725  * Returns whether the printer is accepting jobs
 726  *
 727  * Return value: %TRUE if @printer is accepting jobs
 728  *
 729  * Since: 2.14
 730  */
 731 gboolean
 732 gtk_printer_is_accepting_jobs (GtkPrinter *printer)
 733 {
 734   g_return_val_if_fail (GTK_IS_PRINTER (printer), TRUE);
 735
 736   return printer->priv->is_accepting_jobs;
 737 }
 738
 739 gboolean
 740 gtk_printer_set_is_accepting_jobs (GtkPrinter *printer,
 741                                    gboolean val)
 742 {
 743   GtkPrinterPrivate *priv;
 744
 745   g_return_val_if_fail (GTK_IS_PRINTER (printer), FALSE);
 746
 747   priv = printer->priv;
 748
 749   if (val == priv->is_accepting_jobs)
 750     return FALSE;
 751
 752   priv->is_accepting_jobs = val;
 753
 754   return TRUE;
 755 }
 756
 757 /**
 758  * gtk_printer_is_virtual:
 759  * @printer: a #GtkPrinter
 760  *
 761  * Returns whether the printer is virtual (i.e. does not
 762  * represent actual printer hardware, but something like
 763  * a CUPS class).
 764  *
 765  * Return value: %TRUE if @printer is virtual
 766  *
 767  * Since: 2.10
 768  */
 769 gboolean
 770 gtk_printer_is_virtual (GtkPrinter *printer)
 771 {
 772   g_return_val_if_fail (GTK_IS_PRINTER (printer), TRUE);
 773
 774   return printer->priv->is_virtual;
 775 }
 776
 777 /**
 778  * gtk_printer_accepts_pdf:
 779  * @printer: a #GtkPrinter
 780  *
 781  * Returns whether the printer accepts input in
 782  * PDF format.
 783  *
 784  * Return value: %TRUE if @printer accepts PDF
 785  *
 786  * Since: 2.10
 787  */
 788 gboolean
 789 gtk_printer_accepts_pdf (GtkPrinter *printer)
 790 {
 791   g_return_val_if_fail (GTK_IS_PRINTER (printer), TRUE);
 792
 793   return printer->priv->accepts_pdf;
 794 }
 795
 796 void
 797 gtk_printer_set_accepts_pdf (GtkPrinter *printer,
 798                              gboolean val)
 799 {
 800   g_return_if_fail (GTK_IS_PRINTER (printer));
 801
 802   printer->priv->accepts_pdf = val;
 803 }
 804
 805 /**
 806  * gtk_printer_accepts_ps:
 807  * @printer: a #GtkPrinter
 808  *
 809  * Returns whether the printer accepts input in
 810  * PostScript format.
 811  *
 812  * Return value: %TRUE if @printer accepts PostScript
 813  *
 814  * Since: 2.10
 815  */
 816 gboolean
 817 gtk_printer_accepts_ps (GtkPrinter *printer)
 818 {
 819   g_return_val_if_fail (GTK_IS_PRINTER (printer), TRUE);
 820
 821   return printer->priv->accepts_ps;
 822 }
 823
 824 void
 825 gtk_printer_set_accepts_ps (GtkPrinter *printer,
 826                             gboolean val)
 827 {
 828   g_return_if_fail (GTK_IS_PRINTER (printer));
 829
 830   printer->priv->accepts_ps = val;
 831 }
 832
 833 gboolean
 834 gtk_printer_is_new (GtkPrinter *printer)
 835 {
 836   g_return_val_if_fail (GTK_IS_PRINTER (printer), FALSE);
 837
 838   return printer->priv->is_new;
 839 }
 840
 841 void
 842 gtk_printer_set_is_new (GtkPrinter *printer,
 843                         gboolean val)
 844 {
 845   g_return_if_fail (GTK_IS_PRINTER (printer));
 846
 847   printer->priv->is_new = val;
 848 }
 849
 850
 851 /**
 852  * gtk_printer_is_default:
 853  * @printer: a #GtkPrinter
 854  *
 855  * Returns whether the printer is the default printer.
 856  *
 857  * Return value: %TRUE if @printer is the default
 858  *
 859  * Since: 2.10
 860  */
 861 gboolean
 862 gtk_printer_is_default (GtkPrinter *printer)
 863 {
 864   g_return_val_if_fail (GTK_IS_PRINTER (printer), FALSE);
 865
 866   return printer->priv->is_default;
 867 }
 868
 869 void
 870 gtk_printer_set_is_default (GtkPrinter *printer,
 871                             gboolean    val)
 872 {
 873   g_return_if_fail (GTK_IS_PRINTER (printer));
 874
 875   printer->priv->is_default = val;
 876 }
 877
 878 /**
 879  * gtk_printer_request_details:
 880  * @printer: a #GtkPrinter
 881  *
 882  * Requests the printer details. When the details are available,
 883  * the #GtkPrinter::details-acquired signal will be emitted on @printer.
 884  *
 885  * Since: 2.12
 886  */
 887 void
 888 gtk_printer_request_details (GtkPrinter *printer)
 889 {
 890   GtkPrintBackendClass *backend_class;
 891
 892   g_return_if_fail (GTK_IS_PRINTER (printer));
 893
 894   backend_class = GTK_PRINT_BACKEND_GET_CLASS (printer->priv->backend);
 895   backend_class->printer_request_details (printer);
 896 }
 897
 898 GtkPrinterOptionSet *
 899 _gtk_printer_get_options (GtkPrinter           *printer,
 900                           GtkPrintSettings     *settings,
 901                           GtkPageSetup         *page_setup,
 902                           GtkPrintCapabilities  capabilities)
 903 {
 904   GtkPrintBackendClass *backend_class = GTK_PRINT_BACKEND_GET_CLASS (printer->priv->backend);
 905   return backend_class->printer_get_options (printer, settings, page_setup, capabilities);
 906 }
 907
 908 gboolean
 909 _gtk_printer_mark_conflicts (GtkPrinter          *printer,
 910                              GtkPrinterOptionSet *options)
 911 {
 912   GtkPrintBackendClass *backend_class = GTK_PRINT_BACKEND_GET_CLASS (printer->priv->backend);
 913   return backend_class->printer_mark_conflicts (printer, options);
 914 }
 915
 916 void
 917 _gtk_printer_get_settings_from_options (GtkPrinter          *printer,
 918                                         GtkPrinterOptionSet *options,
 919                                         GtkPrintSettings    *settings)
 920 {
 921   GtkPrintBackendClass *backend_class = GTK_PRINT_BACKEND_GET_CLASS (printer->priv->backend);
 922   backend_class->printer_get_settings_from_options (printer, options, settings);
 923 }
 924
 925 void
 926 _gtk_printer_prepare_for_print (GtkPrinter       *printer,
 927                                 GtkPrintJob      *print_job,
 928                                 GtkPrintSettings *settings,
 929                                 GtkPageSetup     *page_setup)
 930 {
 931   GtkPrintBackendClass *backend_class = GTK_PRINT_BACKEND_GET_CLASS (printer->priv->backend);
 932   backend_class->printer_prepare_for_print (printer, print_job, settings, page_setup);
 933 }
 934
 935 cairo_surface_t *
 936 _gtk_printer_create_cairo_surface (GtkPrinter       *printer,
 937                                    GtkPrintSettings *settings,
 938                                    gdouble           width,
 939                                    gdouble           height,
 940                                    GIOChannel       *cache_io)
 941 {
 942   GtkPrintBackendClass *backend_class = GTK_PRINT_BACKEND_GET_CLASS (printer->priv->backend);
 943
 944   return backend_class->printer_create_cairo_surface (printer, settings,
 945                                                       width, height, cache_io);
 946 }
 947
 948 /**
 949  * gtk_printer_list_papers:
 950  * @printer: a #GtkPrinter
 951  *
 952  * Lists all the paper sizes @printer supports.
 953  * This will return and empty list unless the printer's details are
 954  * available, see gtk_printer_has_details() and gtk_printer_request_details().
 955  *
 956  * Return value: (element-type GtkPageSetup) (transfer full): a newly allocated list of newly allocated #GtkPageSetup s.
 957  *
 958  * Since: 2.12
 959  */
 960 GList  *
 961 gtk_printer_list_papers (GtkPrinter *printer)
 962 {
 963   GtkPrintBackendClass *backend_class;
 964
 965   g_return_val_if_fail (GTK_IS_PRINTER (printer), NULL);
 966
 967   backend_class = GTK_PRINT_BACKEND_GET_CLASS (printer->priv->backend);
 968   return backend_class->printer_list_papers (printer);
 969 }
 970
 971 /**
 972  * gtk_printer_get_default_page_size:
 973  * @printer: a #GtkPrinter
 974  *
 975  * Returns default page size of @printer.
 976  *
 977  * Return value: a newly allocated #GtkPageSetup with default page size of the printer.
 978  *
 979  * Since: 2.14
 980  */
 981 GtkPageSetup  *
 982 gtk_printer_get_default_page_size (GtkPrinter *printer)
 983 {
 984   GtkPrintBackendClass *backend_class;
 985
 986   g_return_val_if_fail (GTK_IS_PRINTER (printer), NULL);
 987
 988   backend_class = GTK_PRINT_BACKEND_GET_CLASS (printer->priv->backend);
 989   return backend_class->printer_get_default_page_size (printer);
 990 }
 991
 992 /**
 993  * gtk_printer_get_hard_margins:
 994  * @printer: a #GtkPrinter
 995  * @top: (out): a location to store the top margin in
 996  * @bottom: (out): a location to store the bottom margin in
 997  * @left: (out): a location to store the left margin in
 998  * @right: (out): a location to store the right margin in
 999  *
1000  * Retrieve the hard margins of @printer, i.e. the margins that define
1001  * the area at the borders of the paper that the printer cannot print to.
1002  *
1003  * Note: This will not succeed unless the printer's details are available,
1004  * see gtk_printer_has_details() and gtk_printer_request_details().
1005  *
1006  * Return value: %TRUE iff the hard margins were retrieved
1007  *
1008  * Since: 2.20
1009  */
1010 gboolean
1011 gtk_printer_get_hard_margins (GtkPrinter *printer,
1012                               gdouble    *top,
1013                               gdouble    *bottom,
1014                               gdouble    *left,
1015                               gdouble    *right)
1016 {
1017   GtkPrintBackendClass *backend_class = GTK_PRINT_BACKEND_GET_CLASS (printer->priv->backend);
1018
1019   return backend_class->printer_get_hard_margins (printer, top, bottom, left, right);
1020 }
1021
1022 /**
1023  * gtk_printer_get_capabilities:
1024  * @printer: a #GtkPrinter
1025  *
1026  * Returns the printer's capabilities.
1027  *
1028  * This is useful when you're using #GtkPrintUnixDialog's manual-capabilities
1029  * setting and need to know which settings the printer can handle and which
1030  * you must handle yourself.
1031  *
1032  * This will return 0 unless the printer's details are available, see
1033  * gtk_printer_has_details() and gtk_printer_request_details().
1034  *
1035  * Return value: the printer's capabilities
1036  *
1037  * Since: 2.12
1038  */
1039 GtkPrintCapabilities
1040 gtk_printer_get_capabilities (GtkPrinter *printer)
1041 {
1042   GtkPrintBackendClass *backend_class;
1043
1044   g_return_val_if_fail (GTK_IS_PRINTER (printer), 0);
1045
1046   backend_class = GTK_PRINT_BACKEND_GET_CLASS (printer->priv->backend);
1047   return backend_class->printer_get_capabilities (printer);
1048 }
1049
1050 /**
1051  * gtk_printer_compare:
1052  * @a: a #GtkPrinter
1053  * @b: another #GtkPrinter
1054  *
1055  * Compares two printers.
1056  *
1057  * Return value: 0 if the printer match, a negative value if @a &lt; @b,
1058  *   or a positive value if @a &gt; @b
1059  *
1060  * Since: 2.10
1061  */
1062 gint
1063 gtk_printer_compare (GtkPrinter *a,
1064                      GtkPrinter *b)
1065 {
1066   const char *name_a, *name_b;
1067
1068   g_assert (GTK_IS_PRINTER (a) && GTK_IS_PRINTER (b));
1069
1070   name_a = gtk_printer_get_name (a);
1071   name_b = gtk_printer_get_name (b);
1072   if (name_a == NULL  && name_b == NULL)
1073     return 0;
1074   else if (name_a == NULL)
1075     return G_MAXINT;
1076   else if (name_b == NULL)
1077     return G_MININT;
1078   else
1079     return g_ascii_strcasecmp (name_a, name_b);
1080 }
1081
1082
1083 typedef struct
1084 {
1085   GList *backends;
1086   GtkPrinterFunc func;
1087   gpointer data;
1088   GDestroyNotify destroy;
1089   GMainLoop *loop;
1090 } PrinterList;
1091
1092 static void list_done_cb (GtkPrintBackend *backend,
1093                           PrinterList     *printer_list);
1094
1095 static void
1096 stop_enumeration (PrinterList *printer_list)
1097 {
1098   GList *list, *next;
1099   GtkPrintBackend *backend;
1100
1101   for (list = printer_list->backends; list; list = next)
1102     {
1103       next = list->next;
1104       backend = GTK_PRINT_BACKEND (list->data);
1105       list_done_cb (backend, printer_list);
1106     }
1107 }
1108
1109 static void
1110 free_printer_list (PrinterList *printer_list)
1111 {
1112   if (printer_list->destroy)
1113     printer_list->destroy (printer_list->data);
1114
1115   if (printer_list->loop)
1116     {
1117       g_main_loop_quit (printer_list->loop);
1118       g_main_loop_unref (printer_list->loop);
1119     }
1120
1121   g_free (printer_list);
1122 }
1123
1124 static gboolean
1125 list_added_cb (GtkPrintBackend *backend,
1126                GtkPrinter      *printer,
1127                PrinterList     *printer_list)
1128 {
1129   if (printer_list->func (printer, printer_list->data))
1130     {
1131       stop_enumeration (printer_list);
1132       return TRUE;
1133     }
1134
1135   return FALSE;
1136 }
1137
1138 static void
1139 backend_status_changed (GObject    *object,
1140                         GParamSpec *pspec,
1141                         gpointer    data)
1142 {
1143   GtkPrintBackend *backend = GTK_PRINT_BACKEND (object);
1144   PrinterList *printer_list = data;
1145   GtkPrintBackendStatus status;
1146
1147   g_object_get (backend, "status", &status, NULL);
1148
1149   if (status == GTK_PRINT_BACKEND_STATUS_UNAVAILABLE)
1150     list_done_cb (backend, printer_list);
1151 }
1152
1153 static void
1154 list_printers_remove_backend (PrinterList     *printer_list,
1155                               GtkPrintBackend *backend)
1156 {
1157   printer_list->backends = g_list_remove (printer_list->backends, backend);
1158   gtk_print_backend_destroy (backend);
1159   g_object_unref (backend);
1160
1161   if (printer_list->backends == NULL)
1162     free_printer_list (printer_list);
1163 }
1164
1165 static void
1166 list_done_cb (GtkPrintBackend *backend,
1167               PrinterList     *printer_list)
1168 {
1169   g_signal_handlers_disconnect_by_func (backend, list_added_cb, printer_list);
1170   g_signal_handlers_disconnect_by_func (backend, list_done_cb, printer_list);
1171   g_signal_handlers_disconnect_by_func (backend, backend_status_changed, printer_list);
1172
1173   list_printers_remove_backend(printer_list, backend);
1174 }
1175
1176 static gboolean
1177 list_printers_init (PrinterList     *printer_list,
1178                     GtkPrintBackend *backend)
1179 {
1180   GList *list, *node;
1181   GtkPrintBackendStatus status;
1182
1183   list = gtk_print_backend_get_printer_list (backend);
1184
1185   for (node = list; node != NULL; node = node->next)
1186     {
1187       if (list_added_cb (backend, node->data, printer_list))
1188         {
1189           g_list_free (list);
1190           return TRUE;
1191         }
1192     }
1193
1194   g_list_free (list);
1195
1196   g_object_get (backend, "status", &status, NULL);
1197
1198   if (status == GTK_PRINT_BACKEND_STATUS_UNAVAILABLE ||
1199       gtk_print_backend_printer_list_is_done (backend))
1200     list_printers_remove_backend(printer_list, backend);
1201   else
1202     {
1203       g_signal_connect (backend, "printer-added",
1204                         (GCallback) list_added_cb,
1205                         printer_list);
1206       g_signal_connect (backend, "printer-list-done",
1207                         (GCallback) list_done_cb,
1208                         printer_list);
1209       g_signal_connect (backend, "notify::status",
1210                         (GCallback) backend_status_changed,
1211                         printer_list);
1212     }
1213
1214   return FALSE;
1215 }
1216
1217 /**
1218  * gtk_enumerate_printers:
1219  * @func: a function to call for each printer
1220  * @data: user data to pass to @func
1221  * @destroy: function to call if @data is no longer needed
1222  * @wait: if %TRUE, wait in a recursive mainloop until
1223  *    all printers are enumerated; otherwise return early
1224  *
1225  * Calls a function for all #GtkPrinter<!-- -->s.
1226  * If @func returns %TRUE, the enumeration is stopped.
1227  *
1228  * Since: 2.10
1229  */
1230 void
1231 gtk_enumerate_printers (GtkPrinterFunc func,
1232                         gpointer       data,
1233                         GDestroyNotify destroy,
1234                         gboolean       wait)
1235 {
1236   PrinterList *printer_list;
1237   GList *node, *next;
1238   GtkPrintBackend *backend;
1239
1240   printer_list = g_new0 (PrinterList, 1);
1241
1242   printer_list->func = func;
1243   printer_list->data = data;
1244   printer_list->destroy = destroy;
1245
1246   if (g_module_supported ())
1247     printer_list->backends = gtk_print_backend_load_modules ();
1248
1249   if (printer_list->backends == NULL)
1250     {
1251       free_printer_list (printer_list);
1252       return;
1253     }
1254
1255   for (node = printer_list->backends; node != NULL; node = next)
1256     {
1257       next = node->next;
1258       backend = GTK_PRINT_BACKEND (node->data);
1259       if (list_printers_init (printer_list, backend))
1260         return;
1261     }
1262
1263   if (wait && printer_list->backends)
1264     {
1265       printer_list->loop = g_main_loop_new (NULL, FALSE);
1266
1267       gdk_threads_leave ();
1268       g_main_loop_run (printer_list->loop);
1269       gdk_threads_enter ();
1270     }
1271 }
1272
1273 GType
1274 gtk_print_capabilities_get_type (void)
1275 {
1276   static GType etype = 0;
1277
1278   if (G_UNLIKELY (etype == 0))
1279     {
1280       static const GFlagsValue values[] = {
1281         { GTK_PRINT_CAPABILITY_PAGE_SET, "GTK_PRINT_CAPABILITY_PAGE_SET", "page-set" },
1282         { GTK_PRINT_CAPABILITY_COPIES, "GTK_PRINT_CAPABILITY_COPIES", "copies" },
1283         { GTK_PRINT_CAPABILITY_COLLATE, "GTK_PRINT_CAPABILITY_COLLATE", "collate" },
1284         { GTK_PRINT_CAPABILITY_REVERSE, "GTK_PRINT_CAPABILITY_REVERSE", "reverse" },
1285         { GTK_PRINT_CAPABILITY_SCALE, "GTK_PRINT_CAPABILITY_SCALE", "scale" },
1286         { GTK_PRINT_CAPABILITY_GENERATE_PDF, "GTK_PRINT_CAPABILITY_GENERATE_PDF", "generate-pdf" },
1287         { GTK_PRINT_CAPABILITY_GENERATE_PS, "GTK_PRINT_CAPABILITY_GENERATE_PS", "generate-ps" },
1288         { GTK_PRINT_CAPABILITY_PREVIEW, "GTK_PRINT_CAPABILITY_PREVIEW", "preview" },
1289         { GTK_PRINT_CAPABILITY_NUMBER_UP, "GTK_PRINT_CAPABILITY_NUMBER_UP", "number-up"},
1290         { GTK_PRINT_CAPABILITY_NUMBER_UP_LAYOUT, "GTK_PRINT_CAPABILITY_NUMBER_UP_LAYOUT", "number-up-layout" },
1291         { 0, NULL, NULL }
1292       };
1293
1294       etype = g_flags_register_static (I_("GtkPrintCapabilities"), values);
1295     }
1296
1297   return etype;
1298 }