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   printer->priv = GTK_PRINTER_GET_PRIVATE (printer);
 190
 191   printer->priv->name = NULL;
 192   printer->priv->location = NULL;
 193   printer->priv->description = NULL;
 194   printer->priv->icon_name = NULL;
 195
 196   printer->priv->is_active = TRUE;
 197   printer->priv->is_new = TRUE;
 198   printer->priv->has_details = FALSE;
 199
 200   printer->priv->state_message = NULL;
 201   printer->priv->job_count = 0;
 202 }
 203
 204 static void
 205 gtk_printer_finalize (GObject *object)
 206 {
 207   g_return_if_fail (object != NULL);
 208
 209   GtkPrinter *printer = GTK_PRINTER (object);
 210
 211   g_free (printer->priv->name);
 212   g_free (printer->priv->location);
 213   g_free (printer->priv->description);
 214   g_free (printer->priv->state_message);
 215   g_free (printer->priv->icon_name);
 216
 217   if (G_OBJECT_CLASS (gtk_printer_parent_class)->finalize)
 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
 229   switch (prop_id)
 230     {
 231     case PROP_NAME:
 232       printer->priv->name = g_value_dup_string (value);
 233       break;
 234
 235     case PROP_BACKEND:
 236       printer->priv->backend = GTK_PRINT_BACKEND (g_value_get_object (value));
 237       break;
 238
 239     case PROP_IS_VIRTUAL:
 240       printer->priv->is_virtual = g_value_get_boolean (value);
 241       break;
 242
 243     default:
 244       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 245       break;
 246     }
 247 }
 248
 249 static void
 250 gtk_printer_get_property (GObject    *object,
 251                           guint       prop_id,
 252                           GValue     *value,
 253                           GParamSpec *pspec)
 254 {
 255   GtkPrinter *printer = GTK_PRINTER (object);
 256
 257   switch (prop_id)
 258     {
 259     case PROP_NAME:
 260       if (printer->priv->name)
 261         g_value_set_string (value, printer->priv->name);
 262       else
 263         g_value_set_string (value, "");
 264       break;
 265     case PROP_BACKEND:
 266       g_value_set_object (value, printer->priv->backend);
 267       break;
 268     case PROP_STATE_MESSAGE:
 269       if (printer->priv->state_message)
 270         g_value_set_string (value, printer->priv->state_message);
 271       else
 272         g_value_set_string (value, "");
 273       break;
 274     case PROP_LOCATION:
 275       if (printer->priv->location)
 276         g_value_set_string (value, printer->priv->location);
 277       else
 278         g_value_set_string (value, "");
 279       break;
 280     case PROP_ICON_NAME:
 281       if (printer->priv->icon_name)
 282         g_value_set_string (value, printer->priv->icon_name);
 283       else
 284         g_value_set_string (value, "");
 285       break;
 286     case PROP_JOB_COUNT:
 287       g_value_set_int (value, printer->priv->job_count);
 288       break;
 289     default:
 290       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 291       break;
 292     }
 293 }
 294
 295 /**
 296  * gtk_printer_new:
 297  * @name: the name of the printer
 298  * @backend: a #GtkPrintBackend
 299  * @virtual: whether the printer is virtual
 300  *
 301  * Creates a new #GtkPrinter.
 302  *
 303  * Return value: a new #GtkPrinter
 304  *
 305  * Since: 2.10
 306  **/
 307 GtkPrinter *
 308 gtk_printer_new (const gchar     *name,
 309                  GtkPrintBackend *backend,
 310                  gboolean         virtual)
 311 {
 312   GObject *result;
 313
 314   result = g_object_new (GTK_TYPE_PRINTER,
 315                          "name", name,
 316                          "backend", backend,
 317                          "is-virtual", virtual,
 318                          NULL);
 319
 320   return (GtkPrinter *) result;
 321 }
 322
 323 /**
 324  * gtk_printer_get_backend:
 325  * @printer: a #GtkPrinter
 326  *
 327  * Returns the backend of the printer.
 328  *
 329  * Return value: the backend of @printer
 330  *
 331  * Since: 2.10
 332  */
 333 GtkPrintBackend *
 334 gtk_printer_get_backend (GtkPrinter *printer)
 335 {
 336   g_return_val_if_fail (GTK_IS_PRINTER (printer), NULL);
 337
 338   return printer->priv->backend;
 339 }
 340
 341 void
 342 gtk_printer_set_backend (GtkPrinter      *printer,
 343                          GtkPrintBackend *backend)
 344 {
 345   g_return_if_fail (GTK_IS_PRINTER (printer));
 346   g_return_if_fail (GTK_IS_PRINT_BACKEND (backend));
 347
 348   printer->priv->backend = backend;
 349 }
 350
 351 /**
 352  * gtk_printer_get_name:
 353  * @printer: a #GtkPrinter
 354  *
 355  * Returns the name of the printer.
 356  *
 357  * Return value: the name of @printer
 358  *
 359  * Since: 2.10
 360  */
 361 G_CONST_RETURN gchar *
 362 gtk_printer_get_name (GtkPrinter *printer)
 363 {
 364   g_return_val_if_fail (GTK_IS_PRINTER (printer), NULL);
 365
 366   return printer->priv->name;
 367 }
 368
 369 /**
 370  * gtk_printer_get_description:
 371  * @printer: a #GtkPrinter
 372  *
 373  * Gets the description of the printer.
 374  *
 375  * Return value: the description of @printer
 376  *
 377  * Since: 2.10
 378  */
 379 G_CONST_RETURN gchar *
 380 gtk_printer_get_description (GtkPrinter *printer)
 381 {
 382   g_return_val_if_fail (GTK_IS_PRINTER (printer), NULL);
 383
 384   return printer->priv->description;
 385 }
 386
 387 gboolean
 388 gtk_printer_set_description (GtkPrinter  *printer,
 389                              const gchar *description)
 390 {
 391   g_return_val_if_fail (GTK_IS_PRINTER (printer), FALSE);
 392
 393   if (safe_strcmp (printer->priv->description, description) == 0)
 394     return FALSE;
 395
 396   g_free (printer->priv->description);
 397   printer->priv->description = g_strdup (description);
 398
 399   return TRUE;
 400 }
 401
 402 /**
 403  * gtk_printer_get_state_message:
 404  * @printer: a #GtkPrinter
 405  *
 406  * Returns the state message describing the current state
 407  * of the printer.
 408  *
 409  * Return value: the state message of @printer
 410  *
 411  * Since: 2.10
 412  */
 413 G_CONST_RETURN gchar *
 414 gtk_printer_get_state_message (GtkPrinter *printer)
 415 {
 416   g_return_val_if_fail (GTK_IS_PRINTER (printer), NULL);
 417
 418   return printer->priv->state_message;
 419 }
 420
 421 gboolean
 422 gtk_printer_set_state_message (GtkPrinter  *printer,
 423                                const gchar *message)
 424 {
 425   g_return_val_if_fail (GTK_IS_PRINTER (printer), FALSE);
 426
 427   if (safe_strcmp (printer->priv->state_message, message) == 0)
 428     return FALSE;
 429
 430   g_free (printer->priv->state_message);
 431   printer->priv->state_message = g_strdup (message);
 432   g_object_notify (G_OBJECT (printer), "state-message");
 433
 434   return TRUE;
 435 }
 436
 437 /**
 438  * gtk_printer_get_location:
 439  * @printer: a #GtkPrinter
 440  *
 441  * Returns a  description of the location of the printer.
 442  *
 443  * Return value: the location of @printer
 444  *
 445  * Since: 2.10
 446  */
 447 G_CONST_RETURN gchar *
 448 gtk_printer_get_location (GtkPrinter *printer)
 449 {
 450   g_return_val_if_fail (GTK_IS_PRINTER (printer), NULL);
 451
 452   return printer->priv->location;
 453 }
 454
 455 gboolean
 456 gtk_printer_set_location (GtkPrinter  *printer,
 457                           const gchar *location)
 458 {
 459   g_return_val_if_fail (GTK_IS_PRINTER (printer), FALSE);
 460
 461   if (safe_strcmp (printer->priv->location, location) == 0)
 462     return FALSE;
 463
 464   g_free (printer->priv->location);
 465   printer->priv->location = g_strdup (location);
 466   g_object_notify (G_OBJECT (printer), "location");
 467
 468   return TRUE;
 469 }
 470
 471 /**
 472  * gtk_printer_get_icon_name:
 473  * @printer: a #GtkPrinter
 474  *
 475  * Gets the name of the icon to use for the printer.
 476  *
 477  * Return value: the icon name for @printer
 478  *
 479  * Since: 2.10
 480  */
 481 G_CONST_RETURN gchar *
 482 gtk_printer_get_icon_name (GtkPrinter *printer)
 483 {
 484   g_return_val_if_fail (GTK_IS_PRINTER (printer), NULL);
 485
 486   return printer->priv->icon_name;
 487 }
 488
 489 void
 490 gtk_printer_set_icon_name (GtkPrinter  *printer,
 491                            const gchar *icon)
 492 {
 493   g_return_if_fail (GTK_IS_PRINTER (printer));
 494
 495   g_free (printer->priv->icon_name);
 496   printer->priv->icon_name = g_strdup (icon);
 497   g_object_notify (G_OBJECT (printer), "icon-name");
 498 }
 499
 500 /**
 501  * gtk_printer_get_job_count:
 502  * @printer: a #GtkPrinter
 503  *
 504  * Gets the number of jobs currently queued on the printer.
 505  *
 506  * Return value: the number of jobs on @printer
 507  *
 508  * Since: 2.10
 509  */
 510 gint
 511 gtk_printer_get_job_count (GtkPrinter *printer)
 512 {
 513   g_return_val_if_fail (GTK_IS_PRINTER (printer), 0);
 514
 515   return printer->priv->job_count;
 516 }
 517
 518 gboolean
 519 gtk_printer_set_job_count (GtkPrinter *printer,
 520                            gint        count)
 521 {
 522   g_return_val_if_fail (GTK_IS_PRINTER (printer), FALSE);
 523
 524   if (printer->priv->job_count == count)
 525     return FALSE;
 526
 527   printer->priv->job_count = count;
 528
 529   g_object_notify (G_OBJECT (printer), "job-count");
 530
 531   return TRUE;
 532 }
 533
 534 gboolean
 535 _gtk_printer_has_details (GtkPrinter *printer)
 536 {
 537   return printer->priv->has_details;
 538 }
 539
 540 void
 541 gtk_printer_set_has_details (GtkPrinter *printer,
 542                              gboolean val)
 543 {
 544   printer->priv->has_details = val;
 545 }
 546
 547 /**
 548  * gtk_printer_is_active:
 549  * @printer: a #GtkPrinter
 550  *
 551  * Returns whether the printer is currently active (i.e.
 552  * accepts new jobs).
 553  *
 554  * Return value: %TRUE if @printer is active
 555  *
 556  * Since: 2.10
 557  */
 558 gboolean
 559 gtk_printer_is_active (GtkPrinter *printer)
 560 {
 561   g_return_val_if_fail (GTK_IS_PRINTER (printer), TRUE);
 562
 563   return printer->priv->is_active;
 564 }
 565
 566 void
 567 gtk_printer_set_is_active (GtkPrinter *printer,
 568                            gboolean val)
 569 {
 570   g_return_if_fail (GTK_IS_PRINTER (printer));
 571
 572   printer->priv->is_active = val;
 573 }
 574
 575
 576 /**
 577  * gtk_printer_is_virtual:
 578  * @printer: a #GtkPrinter
 579  *
 580  * Returns whether the printer is virtual (i.e. does not
 581  * represent actual printer hardware, but something like
 582  * a CUPS class).
 583  *
 584  * Return value: %TRUE if @printer is virtual
 585  *
 586  * Since: 2.10
 587  */
 588 gboolean
 589 gtk_printer_is_virtual (GtkPrinter *printer)
 590 {
 591   g_return_val_if_fail (GTK_IS_PRINTER (printer), TRUE);
 592
 593   return printer->priv->is_virtual;
 594 }
 595
 596 gboolean
 597 gtk_printer_is_new (GtkPrinter *printer)
 598 {
 599   g_return_val_if_fail (GTK_IS_PRINTER (printer), FALSE);
 600
 601   return printer->priv->is_new;
 602 }
 603
 604 void
 605 gtk_printer_set_is_new (GtkPrinter *printer,
 606                         gboolean val)
 607 {
 608   g_return_if_fail (GTK_IS_PRINTER (printer));
 609
 610   printer->priv->is_new = val;
 611 }
 612
 613
 614 /**
 615  * gtk_printer_is_default:
 616  * @printer: a #GtkPrinter
 617  *
 618  * Returns whether the printer is the default printer.
 619  *
 620  * Return value: %TRUE if @printer is the default
 621  *
 622  * Since: 2.10
 623  */
 624 gboolean
 625 gtk_printer_is_default (GtkPrinter *printer)
 626 {
 627   g_return_val_if_fail (GTK_IS_PRINTER (printer), FALSE);
 628
 629   return printer->priv->is_default;
 630 }
 631
 632 void
 633 gtk_printer_set_is_default (GtkPrinter *printer,
 634                             gboolean    val)
 635 {
 636   g_return_if_fail (GTK_IS_PRINTER (printer));
 637
 638   printer->priv->is_default = TRUE;
 639 }
 640
 641 void
 642 _gtk_printer_request_details (GtkPrinter *printer)
 643 {
 644   GtkPrintBackendIface *backend_iface = GTK_PRINT_BACKEND_GET_IFACE (printer->priv->backend);
 645   return backend_iface->printer_request_details (printer);
 646 }
 647
 648 GtkPrinterOptionSet *
 649 _gtk_printer_get_options (GtkPrinter       *printer,
 650                           GtkPrintSettings *settings,
 651                           GtkPageSetup     *page_setup)
 652 {
 653   GtkPrintBackendIface *backend_iface = GTK_PRINT_BACKEND_GET_IFACE (printer->priv->backend);
 654   return backend_iface->printer_get_options (printer, settings, page_setup);
 655 }
 656
 657 gboolean
 658 _gtk_printer_mark_conflicts (GtkPrinter          *printer,
 659                              GtkPrinterOptionSet *options)
 660 {
 661   GtkPrintBackendIface *backend_iface = GTK_PRINT_BACKEND_GET_IFACE (printer->priv->backend);
 662   return backend_iface->printer_mark_conflicts (printer, options);
 663 }
 664
 665 void
 666 _gtk_printer_get_settings_from_options (GtkPrinter          *printer,
 667                                         GtkPrinterOptionSet *options,
 668                                         GtkPrintSettings    *settings)
 669 {
 670   GtkPrintBackendIface *backend_iface = GTK_PRINT_BACKEND_GET_IFACE (printer->priv->backend);
 671   return backend_iface->printer_get_settings_from_options (printer, options, settings);
 672 }
 673
 674 void
 675 _gtk_printer_prepare_for_print (GtkPrinter       *printer,
 676                                 GtkPrintJob      *print_job,
 677                                 GtkPrintSettings *settings,
 678                                 GtkPageSetup     *page_setup)
 679 {
 680   GtkPrintBackendIface *backend_iface = GTK_PRINT_BACKEND_GET_IFACE (printer->priv->backend);
 681   return backend_iface->printer_prepare_for_print (printer, print_job, settings, page_setup);
 682 }
 683
 684 cairo_surface_t *
 685 _gtk_printer_create_cairo_surface (GtkPrinter *printer,
 686                                    gdouble     width,
 687                                    gdouble     height,
 688                                    gint        cache_fd)
 689 {
 690   GtkPrintBackendIface *backend_iface = GTK_PRINT_BACKEND_GET_IFACE (printer->priv->backend);
 691
 692   return backend_iface->printer_create_cairo_surface (printer, width, height, cache_fd);
 693 }
 694
 695 GList  *
 696 _gtk_printer_list_papers (GtkPrinter *printer)
 697 {
 698   GtkPrintBackendIface *backend_iface = GTK_PRINT_BACKEND_GET_IFACE (printer->priv->backend);
 699
 700   return backend_iface->printer_list_papers (printer);
 701 }
 702
 703 void
 704 _gtk_printer_get_hard_margins (GtkPrinter *printer,
 705                                gdouble    *top,
 706                                gdouble    *bottom,
 707                                gdouble    *left,
 708                                gdouble    *right)
 709 {
 710   GtkPrintBackendIface *backend_iface = GTK_PRINT_BACKEND_GET_IFACE (printer->priv->backend);
 711
 712   backend_iface->printer_get_hard_margins (printer, top, bottom, left, right);
 713 }
 714
 715 #define __GTK_PRINTER_C__
 716 #include "gtkaliasdef.c"