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_new: 1;
  48   guint is_virtual : 1;
  49   guint is_default : 1;
  50   guint has_details: 1;
  51
  52   gchar *state_message;
  53   gint job_count;
  54
  55   /* Not ref:ed, backend owns printer. */
  56   GtkPrintBackend *backend;
  57 };
  58
  59 enum {
  60   DETAILS_ACQUIRED,
  61   LAST_SIGNAL
  62 };
  63
  64 enum {
  65   PROP_0,
  66   PROP_NAME,
  67   PROP_BACKEND,
  68   PROP_IS_VIRTUAL,
  69   PROP_STATE_MESSAGE,
  70   PROP_LOCATION,
  71   PROP_ICON_NAME,
  72   PROP_JOB_COUNT
  73 };
  74
  75 static guint signals[LAST_SIGNAL] = { 0 };
  76
  77 static void gtk_printer_set_property (GObject      *object,
  78                                       guint         prop_id,
  79                                       const GValue *value,
  80                                       GParamSpec   *pspec);
  81 static void gtk_printer_get_property (GObject      *object,
  82                                       guint         prop_id,
  83                                       GValue       *value,
  84                                       GParamSpec   *pspec);
  85
  86 G_DEFINE_TYPE (GtkPrinter, gtk_printer, G_TYPE_OBJECT);
  87
  88 static int
  89 safe_strcmp (const char *a, const char *b)
  90 {
  91   if (a == b)
  92     return 0;
  93   if (a == NULL)
  94     return -1;
  95   if (b == NULL)
  96     return 1;
  97   return strcmp (a, b);
  98 }
  99
 100 static void
 101 gtk_printer_class_init (GtkPrinterClass *class)
 102 {
 103   GObjectClass *object_class;
 104   object_class = (GObjectClass *) class;
 105
 106   object_class->finalize = gtk_printer_finalize;
 107
 108   object_class->set_property = gtk_printer_set_property;
 109   object_class->get_property = gtk_printer_get_property;
 110
 111   g_type_class_add_private (class, sizeof (GtkPrinterPrivate));
 112
 113   g_object_class_install_property (G_OBJECT_CLASS (class),
 114                                    PROP_NAME,
 115                                    g_param_spec_string ("name",
 116                                                         P_("Name"),
 117                                                         P_("Name of the printer"),
 118                                                         NULL,
 119                                                         GTK_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY));
 120   g_object_class_install_property (G_OBJECT_CLASS (class),
 121                                    PROP_BACKEND,
 122                                    g_param_spec_object ("backend",
 123                                                         P_("Backend"),
 124                                                         P_("Backend for the printer"),
 125                                                         GTK_TYPE_PRINT_BACKEND,
 126                                                         GTK_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY));
 127   g_object_class_install_property (G_OBJECT_CLASS (class),
 128                                    PROP_IS_VIRTUAL,
 129                                    g_param_spec_boolean ("is-virtual",
 130                                                          P_("Is Virtual"),
 131                                                          P_("FALSE if this represents a real hardware printer"),
 132                                                          FALSE,
 133                                                          GTK_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY));
 134   g_object_class_install_property (G_OBJECT_CLASS (class),
 135                                    PROP_STATE_MESSAGE,
 136                                    g_param_spec_string ("state-message",
 137                                                         P_("State Message"),
 138                                                         P_("String giving the current state of the printer"),
 139                                                         NULL,
 140                                                         GTK_PARAM_READABLE));
 141   g_object_class_install_property (G_OBJECT_CLASS (class),
 142                                    PROP_LOCATION,
 143                                    g_param_spec_string ("location",
 144                                                         P_("Location"),
 145                                                         P_("The location of the printer"),
 146                                                         NULL,
 147                                                         GTK_PARAM_READABLE));
 148   g_object_class_install_property (G_OBJECT_CLASS (class),
 149                                    PROP_ICON_NAME,
 150                                    g_param_spec_string ("icon-name",
 151                                                         P_("Icon Name"),
 152                                                         P_("The icon name to use for the printer"),
 153                                                         NULL,
 154                                                         GTK_PARAM_READABLE));
 155   g_object_class_install_property (G_OBJECT_CLASS (class),
 156                                    PROP_JOB_COUNT,
 157                                    g_param_spec_int ("job-count",
 158                                                      P_("Job Count"),
 159                                                      P_("Number of jobs queued in the printer"),
 160                                                      0,
 161                                                      G_MAXINT,
 162                                                      0,
 163                                                      GTK_PARAM_READABLE));
 164
 165   /**
 166    * GtkPrinter::details-acquired:
 167    * @printer: the #GtkPrinter on which the signal is emitted
 168    * @success: %TRUE if the details were successfully acquired
 169    *
 170    * Gets emitted in response to a request for detailed information
 171    * about a printer from the print backend. The @success parameter
 172    * indicates if the information was actually obtained.
 173    *
 174    * Since: 2.10
 175    */
 176   signals[DETAILS_ACQUIRED] =
 177    g_signal_new ("details-acquired",
 178                  G_TYPE_FROM_CLASS (class),
 179                  G_SIGNAL_RUN_LAST,
 180                  G_STRUCT_OFFSET (GtkPrinterClass, details_acquired),
 181                  NULL, NULL,
 182                  g_cclosure_marshal_VOID__BOOLEAN,
 183                  G_TYPE_NONE, 1, G_TYPE_BOOLEAN);
 184 }
 185
 186 static void
 187 gtk_printer_init (GtkPrinter *printer)
 188 {
 189   GtkPrinterPrivate *priv;
 190
 191   priv = printer->priv = GTK_PRINTER_GET_PRIVATE (printer);
 192
 193   priv->name = NULL;
 194   priv->location = NULL;
 195   priv->description = NULL;
 196   priv->icon_name = NULL;
 197
 198   priv->is_active = TRUE;
 199   priv->is_new = TRUE;
 200   priv->has_details = FALSE;
 201
 202   priv->state_message = NULL;
 203   priv->job_count = 0;
 204 }
 205
 206 static void
 207 gtk_printer_finalize (GObject *object)
 208 {
 209   GtkPrinter *printer = GTK_PRINTER (object);
 210   GtkPrinterPrivate *priv = printer->priv;
 211
 212   g_free (priv->name);
 213   g_free (priv->location);
 214   g_free (priv->description);
 215   g_free (priv->state_message);
 216   g_free (priv->icon_name);
 217
 218   G_OBJECT_CLASS (gtk_printer_parent_class)->finalize (object);
 219 }
 220
 221 static void
 222 gtk_printer_set_property (GObject         *object,
 223                           guint            prop_id,
 224                           const GValue    *value,
 225                           GParamSpec      *pspec)
 226 {
 227   GtkPrinter *printer = GTK_PRINTER (object);
 228   GtkPrinterPrivate *priv = printer->priv;
 229
 230   switch (prop_id)
 231     {
 232     case PROP_NAME:
 233       priv->name = g_value_dup_string (value);
 234       break;
 235
 236     case PROP_BACKEND:
 237       priv->backend = GTK_PRINT_BACKEND (g_value_get_object (value));
 238       break;
 239
 240     case PROP_IS_VIRTUAL:
 241       priv->is_virtual = g_value_get_boolean (value);
 242       break;
 243
 244     default:
 245       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 246       break;
 247     }
 248 }
 249
 250 static void
 251 gtk_printer_get_property (GObject    *object,
 252                           guint       prop_id,
 253                           GValue     *value,
 254                           GParamSpec *pspec)
 255 {
 256   GtkPrinter *printer = GTK_PRINTER (object);
 257   GtkPrinterPrivate *priv = printer->priv;
 258
 259   switch (prop_id)
 260     {
 261     case PROP_NAME:
 262       if (priv->name)
 263         g_value_set_string (value, priv->name);
 264       else
 265         g_value_set_string (value, "");
 266       break;
 267     case PROP_BACKEND:
 268       g_value_set_object (value, priv->backend);
 269       break;
 270     case PROP_STATE_MESSAGE:
 271       if (priv->state_message)
 272         g_value_set_string (value, priv->state_message);
 273       else
 274         g_value_set_string (value, "");
 275       break;
 276     case PROP_LOCATION:
 277       if (priv->location)
 278         g_value_set_string (value, priv->location);
 279       else
 280         g_value_set_string (value, "");
 281       break;
 282     case PROP_ICON_NAME:
 283       if (priv->icon_name)
 284         g_value_set_string (value, priv->icon_name);
 285       else
 286         g_value_set_string (value, "");
 287       break;
 288     case PROP_JOB_COUNT:
 289       g_value_set_int (value, priv->job_count);
 290       break;
 291     default:
 292       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 293       break;
 294     }
 295 }
 296
 297 /**
 298  * gtk_printer_new:
 299  * @name: the name of the printer
 300  * @backend: a #GtkPrintBackend
 301  * @virtual: whether the printer is virtual
 302  *
 303  * Creates a new #GtkPrinter.
 304  *
 305  * Return value: a new #GtkPrinter
 306  *
 307  * Since: 2.10
 308  **/
 309 GtkPrinter *
 310 gtk_printer_new (const gchar     *name,
 311                  GtkPrintBackend *backend,
 312                  gboolean         virtual)
 313 {
 314   GObject *result;
 315
 316   result = g_object_new (GTK_TYPE_PRINTER,
 317                          "name", name,
 318                          "backend", backend,
 319                          "is-virtual", virtual,
 320                          NULL);
 321
 322   return (GtkPrinter *) result;
 323 }
 324
 325 /**
 326  * gtk_printer_get_backend:
 327  * @printer: a #GtkPrinter
 328  *
 329  * Returns the backend of the printer.
 330  *
 331  * Return value: the backend of @printer
 332  *
 333  * Since: 2.10
 334  */
 335 GtkPrintBackend *
 336 gtk_printer_get_backend (GtkPrinter *printer)
 337 {
 338   g_return_val_if_fail (GTK_IS_PRINTER (printer), NULL);
 339
 340   return printer->priv->backend;
 341 }
 342
 343 void
 344 gtk_printer_set_backend (GtkPrinter      *printer,
 345                          GtkPrintBackend *backend)
 346 {
 347   g_return_if_fail (GTK_IS_PRINTER (printer));
 348   g_return_if_fail (GTK_IS_PRINT_BACKEND (backend));
 349
 350   printer->priv->backend = backend;
 351 }
 352
 353 /**
 354  * gtk_printer_get_name:
 355  * @printer: a #GtkPrinter
 356  *
 357  * Returns the name of the printer.
 358  *
 359  * Return value: the name of @printer
 360  *
 361  * Since: 2.10
 362  */
 363 G_CONST_RETURN gchar *
 364 gtk_printer_get_name (GtkPrinter *printer)
 365 {
 366   g_return_val_if_fail (GTK_IS_PRINTER (printer), NULL);
 367
 368   return printer->priv->name;
 369 }
 370
 371 /**
 372  * gtk_printer_get_description:
 373  * @printer: a #GtkPrinter
 374  *
 375  * Gets the description of the printer.
 376  *
 377  * Return value: the description of @printer
 378  *
 379  * Since: 2.10
 380  */
 381 G_CONST_RETURN gchar *
 382 gtk_printer_get_description (GtkPrinter *printer)
 383 {
 384   g_return_val_if_fail (GTK_IS_PRINTER (printer), NULL);
 385
 386   return printer->priv->description;
 387 }
 388
 389 gboolean
 390 gtk_printer_set_description (GtkPrinter  *printer,
 391                              const gchar *description)
 392 {
 393   GtkPrinterPrivate *priv;
 394
 395   g_return_val_if_fail (GTK_IS_PRINTER (printer), FALSE);
 396
 397   priv = printer->priv;
 398
 399   if (safe_strcmp (priv->description, description) == 0)
 400     return FALSE;
 401
 402   g_free (priv->description);
 403   priv->description = g_strdup (description);
 404
 405   return TRUE;
 406 }
 407
 408 /**
 409  * gtk_printer_get_state_message:
 410  * @printer: a #GtkPrinter
 411  *
 412  * Returns the state message describing the current state
 413  * of the printer.
 414  *
 415  * Return value: the state message of @printer
 416  *
 417  * Since: 2.10
 418  */
 419 G_CONST_RETURN gchar *
 420 gtk_printer_get_state_message (GtkPrinter *printer)
 421 {
 422   g_return_val_if_fail (GTK_IS_PRINTER (printer), NULL);
 423
 424   return printer->priv->state_message;
 425 }
 426
 427 gboolean
 428 gtk_printer_set_state_message (GtkPrinter  *printer,
 429                                const gchar *message)
 430 {
 431   GtkPrinterPrivate *priv;
 432
 433   g_return_val_if_fail (GTK_IS_PRINTER (printer), FALSE);
 434
 435   priv = printer->priv;
 436
 437   if (safe_strcmp (priv->state_message, message) == 0)
 438     return FALSE;
 439
 440   g_free (priv->state_message);
 441   priv->state_message = g_strdup (message);
 442   g_object_notify (G_OBJECT (printer), "state-message");
 443
 444   return TRUE;
 445 }
 446
 447 /**
 448  * gtk_printer_get_location:
 449  * @printer: a #GtkPrinter
 450  *
 451  * Returns a  description of the location of the printer.
 452  *
 453  * Return value: the location of @printer
 454  *
 455  * Since: 2.10
 456  */
 457 G_CONST_RETURN gchar *
 458 gtk_printer_get_location (GtkPrinter *printer)
 459 {
 460   g_return_val_if_fail (GTK_IS_PRINTER (printer), NULL);
 461
 462   return printer->priv->location;
 463 }
 464
 465 gboolean
 466 gtk_printer_set_location (GtkPrinter  *printer,
 467                           const gchar *location)
 468 {
 469   GtkPrinterPrivate *priv;
 470
 471   g_return_val_if_fail (GTK_IS_PRINTER (printer), FALSE);
 472
 473   priv = printer->priv;
 474
 475   if (safe_strcmp (priv->location, location) == 0)
 476     return FALSE;
 477
 478   g_free (priv->location);
 479   priv->location = g_strdup (location);
 480   g_object_notify (G_OBJECT (printer), "location");
 481
 482   return TRUE;
 483 }
 484
 485 /**
 486  * gtk_printer_get_icon_name:
 487  * @printer: a #GtkPrinter
 488  *
 489  * Gets the name of the icon to use for the printer.
 490  *
 491  * Return value: the icon name for @printer
 492  *
 493  * Since: 2.10
 494  */
 495 G_CONST_RETURN gchar *
 496 gtk_printer_get_icon_name (GtkPrinter *printer)
 497 {
 498   g_return_val_if_fail (GTK_IS_PRINTER (printer), NULL);
 499
 500   return printer->priv->icon_name;
 501 }
 502
 503 void
 504 gtk_printer_set_icon_name (GtkPrinter  *printer,
 505                            const gchar *icon)
 506 {
 507   GtkPrinterPrivate *priv;
 508
 509   g_return_if_fail (GTK_IS_PRINTER (printer));
 510
 511   priv = printer->priv;
 512
 513   g_free (priv->icon_name);
 514   priv->icon_name = g_strdup (icon);
 515   g_object_notify (G_OBJECT (printer), "icon-name");
 516 }
 517
 518 /**
 519  * gtk_printer_get_job_count:
 520  * @printer: a #GtkPrinter
 521  *
 522  * Gets the number of jobs currently queued on the printer.
 523  *
 524  * Return value: the number of jobs on @printer
 525  *
 526  * Since: 2.10
 527  */
 528 gint
 529 gtk_printer_get_job_count (GtkPrinter *printer)
 530 {
 531   g_return_val_if_fail (GTK_IS_PRINTER (printer), 0);
 532
 533   return printer->priv->job_count;
 534 }
 535
 536 gboolean
 537 gtk_printer_set_job_count (GtkPrinter *printer,
 538                            gint        count)
 539 {
 540   GtkPrinterPrivate *priv;
 541
 542   g_return_val_if_fail (GTK_IS_PRINTER (printer), FALSE);
 543
 544   priv = printer->priv;
 545
 546   if (priv->job_count == count)
 547     return FALSE;
 548
 549   priv->job_count = count;
 550
 551   g_object_notify (G_OBJECT (printer), "job-count");
 552
 553   return TRUE;
 554 }
 555
 556 gboolean
 557 _gtk_printer_has_details (GtkPrinter *printer)
 558 {
 559   return printer->priv->has_details;
 560 }
 561
 562 void
 563 gtk_printer_set_has_details (GtkPrinter *printer,
 564                              gboolean val)
 565 {
 566   printer->priv->has_details = val;
 567 }
 568
 569 /**
 570  * gtk_printer_is_active:
 571  * @printer: a #GtkPrinter
 572  *
 573  * Returns whether the printer is currently active (i.e.
 574  * accepts new jobs).
 575  *
 576  * Return value: %TRUE if @printer is active
 577  *
 578  * Since: 2.10
 579  */
 580 gboolean
 581 gtk_printer_is_active (GtkPrinter *printer)
 582 {
 583   g_return_val_if_fail (GTK_IS_PRINTER (printer), TRUE);
 584
 585   return printer->priv->is_active;
 586 }
 587
 588 void
 589 gtk_printer_set_is_active (GtkPrinter *printer,
 590                            gboolean val)
 591 {
 592   g_return_if_fail (GTK_IS_PRINTER (printer));
 593
 594   printer->priv->is_active = val;
 595 }
 596
 597
 598 /**
 599  * gtk_printer_is_virtual:
 600  * @printer: a #GtkPrinter
 601  *
 602  * Returns whether the printer is virtual (i.e. does not
 603  * represent actual printer hardware, but something like
 604  * a CUPS class).
 605  *
 606  * Return value: %TRUE if @printer is virtual
 607  *
 608  * Since: 2.10
 609  */
 610 gboolean
 611 gtk_printer_is_virtual (GtkPrinter *printer)
 612 {
 613   g_return_val_if_fail (GTK_IS_PRINTER (printer), TRUE);
 614
 615   return printer->priv->is_virtual;
 616 }
 617
 618 gboolean
 619 gtk_printer_is_new (GtkPrinter *printer)
 620 {
 621   g_return_val_if_fail (GTK_IS_PRINTER (printer), FALSE);
 622
 623   return printer->priv->is_new;
 624 }
 625
 626 void
 627 gtk_printer_set_is_new (GtkPrinter *printer,
 628                         gboolean val)
 629 {
 630   g_return_if_fail (GTK_IS_PRINTER (printer));
 631
 632   printer->priv->is_new = val;
 633 }
 634
 635
 636 /**
 637  * gtk_printer_is_default:
 638  * @printer: a #GtkPrinter
 639  *
 640  * Returns whether the printer is the default printer.
 641  *
 642  * Return value: %TRUE if @printer is the default
 643  *
 644  * Since: 2.10
 645  */
 646 gboolean
 647 gtk_printer_is_default (GtkPrinter *printer)
 648 {
 649   g_return_val_if_fail (GTK_IS_PRINTER (printer), FALSE);
 650
 651   return printer->priv->is_default;
 652 }
 653
 654 void
 655 gtk_printer_set_is_default (GtkPrinter *printer,
 656                             gboolean    val)
 657 {
 658   g_return_if_fail (GTK_IS_PRINTER (printer));
 659
 660   printer->priv->is_default = TRUE;
 661 }
 662
 663 void
 664 _gtk_printer_request_details (GtkPrinter *printer)
 665 {
 666   GtkPrintBackendIface *backend_iface = GTK_PRINT_BACKEND_GET_IFACE (printer->priv->backend);
 667   return backend_iface->printer_request_details (printer);
 668 }
 669
 670 GtkPrinterOptionSet *
 671 _gtk_printer_get_options (GtkPrinter       *printer,
 672                           GtkPrintSettings *settings,
 673                           GtkPageSetup     *page_setup)
 674 {
 675   GtkPrintBackendIface *backend_iface = GTK_PRINT_BACKEND_GET_IFACE (printer->priv->backend);
 676   return backend_iface->printer_get_options (printer, settings, page_setup);
 677 }
 678
 679 gboolean
 680 _gtk_printer_mark_conflicts (GtkPrinter          *printer,
 681                              GtkPrinterOptionSet *options)
 682 {
 683   GtkPrintBackendIface *backend_iface = GTK_PRINT_BACKEND_GET_IFACE (printer->priv->backend);
 684   return backend_iface->printer_mark_conflicts (printer, options);
 685 }
 686
 687 void
 688 _gtk_printer_get_settings_from_options (GtkPrinter          *printer,
 689                                         GtkPrinterOptionSet *options,
 690                                         GtkPrintSettings    *settings)
 691 {
 692   GtkPrintBackendIface *backend_iface = GTK_PRINT_BACKEND_GET_IFACE (printer->priv->backend);
 693   return backend_iface->printer_get_settings_from_options (printer, options, settings);
 694 }
 695
 696 void
 697 _gtk_printer_prepare_for_print (GtkPrinter       *printer,
 698                                 GtkPrintJob      *print_job,
 699                                 GtkPrintSettings *settings,
 700                                 GtkPageSetup     *page_setup)
 701 {
 702   GtkPrintBackendIface *backend_iface = GTK_PRINT_BACKEND_GET_IFACE (printer->priv->backend);
 703   return backend_iface->printer_prepare_for_print (printer, print_job, settings, page_setup);
 704 }
 705
 706 cairo_surface_t *
 707 _gtk_printer_create_cairo_surface (GtkPrinter *printer,
 708                                    gdouble     width,
 709                                    gdouble     height,
 710                                    gint        cache_fd)
 711 {
 712   GtkPrintBackendIface *backend_iface = GTK_PRINT_BACKEND_GET_IFACE (printer->priv->backend);
 713
 714   return backend_iface->printer_create_cairo_surface (printer, width, height, cache_fd);
 715 }
 716
 717 GList  *
 718 _gtk_printer_list_papers (GtkPrinter *printer)
 719 {
 720   GtkPrintBackendIface *backend_iface = GTK_PRINT_BACKEND_GET_IFACE (printer->priv->backend);
 721
 722   return backend_iface->printer_list_papers (printer);
 723 }
 724
 725 void
 726 _gtk_printer_get_hard_margins (GtkPrinter *printer,
 727                                gdouble    *top,
 728                                gdouble    *bottom,
 729                                gdouble    *left,
 730                                gdouble    *right)
 731 {
 732   GtkPrintBackendIface *backend_iface = GTK_PRINT_BACKEND_GET_IFACE (printer->priv->backend);
 733
 734   backend_iface->printer_get_hard_margins (printer, top, bottom, left, right);
 735 }
 736
 737 #define __GTK_PRINTER_C__
 738 #include "gtkaliasdef.c"