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