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