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