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