gtkprinter.c 29.7 KB
Newer Older
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45
/* GtkPrinter
 * Copyright (C) 2006 John (J5) Palmieri  <johnp@redhat.com>
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the
 * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
 * Boston, MA 02111-1307, USA.
 */

#include "config.h"
#include <stdlib.h>
#include <string.h>
#include <stdio.h>

#include "gtkintl.h"
#include "gtkprivate.h"

#include "gtkprinter.h"
#include "gtkprinter-private.h"
#include "gtkprintbackend.h"
#include "gtkprintjob.h"
#include "gtkalias.h"

#define GTK_PRINTER_GET_PRIVATE(o)  \
   (G_TYPE_INSTANCE_GET_PRIVATE ((o), GTK_TYPE_PRINTER, GtkPrinterPrivate))

static void gtk_printer_finalize     (GObject *object);

struct _GtkPrinterPrivate
{
  gchar *name;
  gchar *location;
  gchar *description;
  gchar *icon_name;

46 47 48 49 50 51 52 53 54
  guint is_active         : 1;
  guint is_paused         : 1;
  guint is_accepting_jobs : 1;
  guint is_new            : 1;
  guint is_virtual        : 1;
  guint is_default        : 1;
  guint has_details       : 1;
  guint accepts_pdf       : 1;
  guint accepts_ps        : 1;
55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74

  gchar *state_message;  
  gint job_count;

  GtkPrintBackend *backend;
};

enum {
  DETAILS_ACQUIRED,
  LAST_SIGNAL
};

enum {
  PROP_0,
  PROP_NAME,
  PROP_BACKEND,
  PROP_IS_VIRTUAL,
  PROP_STATE_MESSAGE,
  PROP_LOCATION,
  PROP_ICON_NAME,
75 76
  PROP_JOB_COUNT,
  PROP_ACCEPTS_PDF,
77 78 79
  PROP_ACCEPTS_PS,
  PROP_PAUSED,
  PROP_ACCEPTING_JOBS
80 81 82 83 84 85 86 87 88 89 90 91 92
};

static guint signals[LAST_SIGNAL] = { 0 };

static void gtk_printer_set_property (GObject      *object,
				      guint         prop_id,
				      const GValue *value,
				      GParamSpec   *pspec);
static void gtk_printer_get_property (GObject      *object,
				      guint         prop_id,
				      GValue       *value,
				      GParamSpec   *pspec);

Matthias Clasen's avatar
Matthias Clasen committed
93
G_DEFINE_TYPE (GtkPrinter, gtk_printer, G_TYPE_OBJECT)
94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124

static int
safe_strcmp (const char *a, const char *b)
{
  if (a == b)
    return 0;
  if (a == NULL)
    return -1;
  if (b == NULL)
    return 1;
  return strcmp (a, b);
}

static void
gtk_printer_class_init (GtkPrinterClass *class)
{
  GObjectClass *object_class;
  object_class = (GObjectClass *) class;

  object_class->finalize = gtk_printer_finalize;

  object_class->set_property = gtk_printer_set_property;
  object_class->get_property = gtk_printer_get_property;

  g_type_class_add_private (class, sizeof (GtkPrinterPrivate));

  g_object_class_install_property (G_OBJECT_CLASS (class),
                                   PROP_NAME,
                                   g_param_spec_string ("name",
						        P_("Name"),
						        P_("Name of the printer"),
125
						        "",
126 127 128 129 130 131 132 133 134 135 136 137
							GTK_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY));
  g_object_class_install_property (G_OBJECT_CLASS (class),
                                   PROP_BACKEND,
                                   g_param_spec_object ("backend",
						        P_("Backend"),
						        P_("Backend for the printer"),
						        GTK_TYPE_PRINT_BACKEND,
							GTK_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY));
  g_object_class_install_property (G_OBJECT_CLASS (class),
                                   PROP_IS_VIRTUAL,
                                   g_param_spec_boolean ("is-virtual",
							 P_("Is Virtual"),
138
							 P_("FALSE if this represents a real hardware printer"),
139 140
							 FALSE,
							 GTK_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY));
141 142 143 144 145 146 147 148 149 150 151 152 153 154
  g_object_class_install_property (G_OBJECT_CLASS (class),
                                   PROP_ACCEPTS_PDF,
                                   g_param_spec_boolean ("accepts-pdf",
							 P_("Accepts PDF"),
							 P_("TRUE if this printer can accept PDF"),
							 TRUE,
							 GTK_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY));
  g_object_class_install_property (G_OBJECT_CLASS (class),
                                   PROP_ACCEPTS_PS,
                                   g_param_spec_boolean ("accepts-ps",
							 P_("Accepts PostScript"),
							 P_("TRUE if this printer can accept PostScript"),
							 TRUE,
							 GTK_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY));
155 156 157 158 159
  g_object_class_install_property (G_OBJECT_CLASS (class),
                                   PROP_STATE_MESSAGE,
                                   g_param_spec_string ("state-message",
						        P_("State Message"),
						        P_("String giving the current state of the printer"),
160
						        "",
161 162 163 164 165 166
							GTK_PARAM_READABLE));
  g_object_class_install_property (G_OBJECT_CLASS (class),
                                   PROP_LOCATION,
                                   g_param_spec_string ("location",
						        P_("Location"),
						        P_("The location of the printer"),
167
						        "",
168 169 170 171 172 173
							GTK_PARAM_READABLE));
  g_object_class_install_property (G_OBJECT_CLASS (class),
                                   PROP_ICON_NAME,
                                   g_param_spec_string ("icon-name",
						        P_("Icon Name"),
						        P_("The icon name to use for the printer"),
174
						        "",
175 176 177 178 179 180 181 182 183 184 185
							GTK_PARAM_READABLE));
  g_object_class_install_property (G_OBJECT_CLASS (class),
                                   PROP_JOB_COUNT,
				   g_param_spec_int ("job-count",
 						     P_("Job Count"),
 						     P_("Number of jobs queued in the printer"),
 						     0,
 						     G_MAXINT,
 						     0,
 						     GTK_PARAM_READABLE));

186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216
  /**
   * GtkPrinter:paused:
   *
   * This property is %TRUE if this printer is paused. 
   * A paused printer still accepts jobs, but it does 
   * not print them.
   *
   * Since: 2.14
   */
  g_object_class_install_property (G_OBJECT_CLASS (class),
                                   PROP_PAUSED,
                                   g_param_spec_boolean ("paused",
							 P_("Paused Printer"),
							 P_("TRUE if this printer is paused"),
							 FALSE,
							 GTK_PARAM_READABLE));
  /**
   * GtkPrinter:accepting-jobs:
   *
   * This property is %TRUE if the printer is accepting jobs.
   *
   * Since: 2.14
   */ 
  g_object_class_install_property (G_OBJECT_CLASS (class),
                                   PROP_ACCEPTING_JOBS,
                                   g_param_spec_boolean ("accepting-jobs",
							 P_("Accepting Jobs"),
							 P_("TRUE if this printer is accepting new jobs"),
							 TRUE,
							 GTK_PARAM_READABLE));

217 218 219 220 221 222 223 224 225 226 227
  /**
   * GtkPrinter::details-acquired:
   * @printer: the #GtkPrinter on which the signal is emitted
   * @success: %TRUE if the details were successfully acquired
   *
   * Gets emitted in response to a request for detailed information
   * about a printer from the print backend. The @success parameter
   * indicates if the information was actually obtained.
   *
   * Since: 2.10
   */
228
  signals[DETAILS_ACQUIRED] =
Matthias Clasen's avatar
Matthias Clasen committed
229 230 231 232 233 234 235
    g_signal_new (I_("details-acquired"),
		  G_TYPE_FROM_CLASS (class),
		  G_SIGNAL_RUN_LAST,
		  G_STRUCT_OFFSET (GtkPrinterClass, details_acquired),
		  NULL, NULL,
		  g_cclosure_marshal_VOID__BOOLEAN,
		  G_TYPE_NONE, 1, G_TYPE_BOOLEAN);
236 237 238 239 240
}

static void
gtk_printer_init (GtkPrinter *printer)
{
241
  GtkPrinterPrivate *priv;
242

243
  priv = printer->priv = GTK_PRINTER_GET_PRIVATE (printer); 
244

245 246 247 248
  priv->name = NULL;
  priv->location = NULL;
  priv->description = NULL;
  priv->icon_name = NULL;
249

250
  priv->is_active = TRUE;
251 252
  priv->is_paused = FALSE;
  priv->is_accepting_jobs = TRUE;
253 254
  priv->is_new = TRUE;
  priv->has_details = FALSE;
255 256
  priv->accepts_pdf = TRUE;
  priv->accepts_ps = TRUE;
257 258 259

  priv->state_message = NULL;  
  priv->job_count = 0;
260 261 262 263 264 265
}

static void
gtk_printer_finalize (GObject *object)
{
  GtkPrinter *printer = GTK_PRINTER (object);
266
  GtkPrinterPrivate *priv = printer->priv;
267

268 269 270 271 272
  g_free (priv->name);
  g_free (priv->location);
  g_free (priv->description);
  g_free (priv->state_message);
  g_free (priv->icon_name);
273

Alexander Larsson's avatar
Alexander Larsson committed
274 275 276
  if (priv->backend)
    g_object_unref (priv->backend);

277
  G_OBJECT_CLASS (gtk_printer_parent_class)->finalize (object);
278 279 280 281 282 283 284 285 286
}

static void
gtk_printer_set_property (GObject         *object,
			  guint            prop_id,
			  const GValue    *value,
			  GParamSpec      *pspec)
{
  GtkPrinter *printer = GTK_PRINTER (object);
287 288
  GtkPrinterPrivate *priv = printer->priv;

289 290 291
  switch (prop_id)
    {
    case PROP_NAME:
292
      priv->name = g_value_dup_string (value);
293 294 295
      break;
    
    case PROP_BACKEND:
Alexander Larsson's avatar
Alexander Larsson committed
296
      priv->backend = GTK_PRINT_BACKEND (g_value_dup_object (value));
297 298 299
      break;

    case PROP_IS_VIRTUAL:
300
      priv->is_virtual = g_value_get_boolean (value);
301 302
      break;

303 304 305 306 307 308 309 310
    case PROP_ACCEPTS_PDF:
      priv->accepts_pdf = g_value_get_boolean (value);
      break;

    case PROP_ACCEPTS_PS:
      priv->accepts_ps = g_value_get_boolean (value);
      break;

311 312 313 314 315 316 317 318 319 320 321 322 323
    default:
      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
      break;
    }
}

static void
gtk_printer_get_property (GObject    *object,
			  guint       prop_id,
			  GValue     *value,
			  GParamSpec *pspec)
{
  GtkPrinter *printer = GTK_PRINTER (object);
324
  GtkPrinterPrivate *priv = printer->priv;
325 326 327 328

  switch (prop_id)
    {
    case PROP_NAME:
329 330
      if (priv->name)
	g_value_set_string (value, priv->name);
331
      else
332
	g_value_set_static_string (value, "");
333 334
      break;
    case PROP_BACKEND:
335
      g_value_set_object (value, priv->backend);
336 337
      break;
    case PROP_STATE_MESSAGE:
338 339
      if (priv->state_message)
	g_value_set_string (value, priv->state_message);
340
      else
341
	g_value_set_static_string (value, "");
342 343
      break;
    case PROP_LOCATION:
344 345
      if (priv->location)
	g_value_set_string (value, priv->location);
346
      else
347
	g_value_set_static_string (value, "");
348 349
      break;
    case PROP_ICON_NAME:
350 351
      if (priv->icon_name)
	g_value_set_string (value, priv->icon_name);
352
      else
353
	g_value_set_static_string (value, "");
354 355
      break;
    case PROP_JOB_COUNT:
356
      g_value_set_int (value, priv->job_count);
357
      break;
358 359 360 361 362 363 364 365 366
    case PROP_IS_VIRTUAL:
      g_value_set_boolean (value, priv->is_virtual);
      break;
    case PROP_ACCEPTS_PDF:
      g_value_set_boolean (value, priv->accepts_pdf);
      break;
    case PROP_ACCEPTS_PS:
      g_value_set_boolean (value, priv->accepts_ps);
      break;
367 368 369 370 371 372
    case PROP_PAUSED:
      g_value_set_boolean (value, priv->is_paused);
      break;
    case PROP_ACCEPTING_JOBS:
      g_value_set_boolean (value, priv->is_accepting_jobs);
      break;
373 374 375 376 377 378 379 380
    default:
      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
      break;
    }
}

/**
 * gtk_printer_new:
381 382
 * @name: the name of the printer
 * @backend: a #GtkPrintBackend
Matthias Clasen's avatar
Matthias Clasen committed
383
 * @virtual_: whether the printer is virtual
384 385 386 387 388
 *
 * Creates a new #GtkPrinter.
 *
 * Return value: a new #GtkPrinter
 *
389
 * Since: 2.10
390 391
 **/
GtkPrinter *
392
gtk_printer_new (const gchar     *name,
393
		 GtkPrintBackend *backend,
Matthias Clasen's avatar
Matthias Clasen committed
394
		 gboolean         virtual_)
395 396 397 398 399 400
{
  GObject *result;
  
  result = g_object_new (GTK_TYPE_PRINTER,
			 "name", name,
			 "backend", backend,
Matthias Clasen's avatar
Matthias Clasen committed
401
			 "is-virtual", virtual_,
402 403 404 405 406
                         NULL);

  return (GtkPrinter *) result;
}

407 408 409 410 411 412 413 414 415 416
/**
 * gtk_printer_get_backend:
 * @printer: a #GtkPrinter
 * 
 * Returns the backend of the printer.
 * 
 * Return value: the backend of @printer
 * 
 * Since: 2.10
 */
417 418 419 420 421 422 423 424
GtkPrintBackend *
gtk_printer_get_backend (GtkPrinter *printer)
{
  g_return_val_if_fail (GTK_IS_PRINTER (printer), NULL);
  
  return printer->priv->backend;
}

425 426 427 428 429 430 431 432 433 434 435
/**
 * gtk_printer_get_name:
 * @printer: a #GtkPrinter
 * 
 * Returns the name of the printer.
 * 
 * Return value: the name of @printer
 *
 * Since: 2.10
 */
G_CONST_RETURN gchar *
436 437 438 439 440 441 442
gtk_printer_get_name (GtkPrinter *printer)
{
  g_return_val_if_fail (GTK_IS_PRINTER (printer), NULL);

  return printer->priv->name;
}

443 444 445 446 447 448 449 450 451 452 453
/**
 * gtk_printer_get_description:
 * @printer: a #GtkPrinter
 * 
 * Gets the description of the printer.
 * 
 * Return value: the description of @printer
 *
 * Since: 2.10
 */
G_CONST_RETURN gchar *
454 455 456 457 458 459 460 461
gtk_printer_get_description (GtkPrinter *printer)
{
  g_return_val_if_fail (GTK_IS_PRINTER (printer), NULL);
  
  return printer->priv->description;
}

gboolean
462 463
gtk_printer_set_description (GtkPrinter  *printer,
			     const gchar *description)
464
{
465 466
  GtkPrinterPrivate *priv;

467 468
  g_return_val_if_fail (GTK_IS_PRINTER (printer), FALSE);

469 470 471
  priv = printer->priv;

  if (safe_strcmp (priv->description, description) == 0)
472 473
    return FALSE;

474 475
  g_free (priv->description);
  priv->description = g_strdup (description);
476 477 478 479
  
  return TRUE;
}

480 481 482 483 484 485 486 487 488 489 490 491
/**
 * gtk_printer_get_state_message:
 * @printer: a #GtkPrinter
 * 
 * Returns the state message describing the current state
 * of the printer.
 * 
 * Return value: the state message of @printer
 *
 * Since: 2.10
 */
G_CONST_RETURN gchar *
492 493 494 495 496 497 498 499
gtk_printer_get_state_message (GtkPrinter *printer)
{
  g_return_val_if_fail (GTK_IS_PRINTER (printer), NULL);

  return printer->priv->state_message;
}

gboolean
500 501
gtk_printer_set_state_message (GtkPrinter  *printer,
			       const gchar *message)
502
{
503 504
  GtkPrinterPrivate *priv;

505 506
  g_return_val_if_fail (GTK_IS_PRINTER (printer), FALSE);

507 508 509
  priv = printer->priv;

  if (safe_strcmp (priv->state_message, message) == 0)
510 511
    return FALSE;

512 513
  g_free (priv->state_message);
  priv->state_message = g_strdup (message);
514 515 516 517 518
  g_object_notify (G_OBJECT (printer), "state-message");

  return TRUE;
}

519 520 521 522
/**
 * gtk_printer_get_location:
 * @printer: a #GtkPrinter
 * 
Matthias Clasen's avatar
Matthias Clasen committed
523
 * Returns a description of the location of the printer.
524 525 526 527 528 529
 * 
 * Return value: the location of @printer
 *
 * Since: 2.10
 */
G_CONST_RETURN gchar *
530 531 532 533 534 535 536 537
gtk_printer_get_location (GtkPrinter *printer)
{
  g_return_val_if_fail (GTK_IS_PRINTER (printer), NULL);

  return printer->priv->location;
}

gboolean
538 539
gtk_printer_set_location (GtkPrinter  *printer,
			  const gchar *location)
540
{
541 542
  GtkPrinterPrivate *priv;

543 544
  g_return_val_if_fail (GTK_IS_PRINTER (printer), FALSE);

545 546 547
  priv = printer->priv;

  if (safe_strcmp (priv->location, location) == 0)
548 549
    return FALSE;

550 551
  g_free (priv->location);
  priv->location = g_strdup (location);
552 553 554 555 556
  g_object_notify (G_OBJECT (printer), "location");
  
  return TRUE;
}

557
/**
558 559 560 561 562 563 564 565 566 567
 * gtk_printer_get_icon_name:
 * @printer: a #GtkPrinter
 * 
 * Gets the name of the icon to use for the printer.
 * 
 * Return value: the icon name for @printer
 *
 * Since: 2.10
 */
G_CONST_RETURN gchar * 
568 569 570 571 572 573 574 575
gtk_printer_get_icon_name (GtkPrinter *printer)
{
  g_return_val_if_fail (GTK_IS_PRINTER (printer), NULL);

  return printer->priv->icon_name;
}

void
576 577
gtk_printer_set_icon_name (GtkPrinter  *printer,
			   const gchar *icon)
578
{
579 580
  GtkPrinterPrivate *priv;

581 582
  g_return_if_fail (GTK_IS_PRINTER (printer));

583 584 585 586
  priv = printer->priv;

  g_free (priv->icon_name);
  priv->icon_name = g_strdup (icon);
587 588 589
  g_object_notify (G_OBJECT (printer), "icon-name");
}

590 591 592 593 594 595 596 597 598 599
/**
 * gtk_printer_get_job_count:
 * @printer: a #GtkPrinter
 * 
 * Gets the number of jobs currently queued on the printer.
 * 
 * Return value: the number of jobs on @printer
 *
 * Since: 2.10
 */
600 601 602 603 604 605 606 607 608 609
gint 
gtk_printer_get_job_count (GtkPrinter *printer)
{
  g_return_val_if_fail (GTK_IS_PRINTER (printer), 0);

  return printer->priv->job_count;
}

gboolean
gtk_printer_set_job_count (GtkPrinter *printer,
610
			   gint        count)
611
{
612 613
  GtkPrinterPrivate *priv;

614 615
  g_return_val_if_fail (GTK_IS_PRINTER (printer), FALSE);

616 617 618
  priv = printer->priv;

  if (priv->job_count == count)
619 620
    return FALSE;

621
  priv->job_count = count;
622 623 624 625 626 627
  
  g_object_notify (G_OBJECT (printer), "job-count");
  
  return TRUE;
}

628 629 630 631 632 633 634 635 636 637
/**
 * gtk_printer_has_details:
 * @printer: a #GtkPrinter
 * 
 * Returns whether the printer details are available.
 * 
 * Return value: %TRUE if @printer details are available
 *
 * Since: 2.12
 */
638
gboolean
639
gtk_printer_has_details (GtkPrinter *printer)
640
{
641 642
  g_return_val_if_fail (GTK_IS_PRINTER (printer), FALSE);

643 644 645 646 647 648 649 650 651 652
  return printer->priv->has_details;
}

void
gtk_printer_set_has_details (GtkPrinter *printer,
			     gboolean val)
{
  printer->priv->has_details = val;
}

653 654 655 656 657 658 659 660 661 662 663
/**
 * gtk_printer_is_active:
 * @printer: a #GtkPrinter
 * 
 * Returns whether the printer is currently active (i.e. 
 * accepts new jobs).
 * 
 * Return value: %TRUE if @printer is active
 *
 * Since: 2.10
 */
664 665 666 667 668 669 670 671 672 673 674 675
gboolean
gtk_printer_is_active (GtkPrinter *printer)
{
  g_return_val_if_fail (GTK_IS_PRINTER (printer), TRUE);
  
  return printer->priv->is_active;
}

void
gtk_printer_set_is_active (GtkPrinter *printer,
			   gboolean val)
{
676 677
  g_return_if_fail (GTK_IS_PRINTER (printer));

678 679 680
  printer->priv->is_active = val;
}

681 682 683 684 685 686 687 688 689 690 691 692 693 694 695 696 697 698 699 700 701 702 703 704 705 706 707 708 709 710 711 712 713 714 715 716 717 718 719 720 721 722 723 724 725 726 727 728 729 730 731 732 733 734 735 736 737 738 739 740 741 742 743 744 745 746 747 748 749 750 751 752 753
/**
 * gtk_printer_is_paused:
 * @printer: a #GtkPrinter
 * 
 * Returns whether the printer is currently paused.
 * A paused printer still accepts jobs, but it is not
 * printing them.
 * 
 * Return value: %TRUE if @printer is paused
 *
 * Since: 2.14
 */
gboolean
gtk_printer_is_paused (GtkPrinter *printer)
{
  g_return_val_if_fail (GTK_IS_PRINTER (printer), TRUE);
  
  return printer->priv->is_paused;
}

gboolean
gtk_printer_set_is_paused (GtkPrinter *printer,
			   gboolean    val)
{
  GtkPrinterPrivate *priv;

  g_return_val_if_fail (GTK_IS_PRINTER (printer), FALSE);

  priv = printer->priv;

  if (val == priv->is_paused)
    return FALSE;

  priv->is_paused = val;

  return TRUE;
}

/**
 * gtk_printer_is_accepting_jobs:
 * @printer: a #GtkPrinter
 * 
 * Returns whether the printer is accepting jobs
 * 
 * Return value: %TRUE if @printer is accepting jobs
 *
 * Since: 2.14
 */
gboolean
gtk_printer_is_accepting_jobs (GtkPrinter *printer)
{
  g_return_val_if_fail (GTK_IS_PRINTER (printer), TRUE);
  
  return printer->priv->is_accepting_jobs;
}

gboolean
gtk_printer_set_is_accepting_jobs (GtkPrinter *printer,
				   gboolean val)
{
  GtkPrinterPrivate *priv;

  g_return_val_if_fail (GTK_IS_PRINTER (printer), FALSE);

  priv = printer->priv;

  if (val == priv->is_accepting_jobs)
    return FALSE;

  priv->is_accepting_jobs = val;

  return TRUE;
}
754

755 756 757 758 759 760 761 762 763 764 765 766
/**
 * gtk_printer_is_virtual:
 * @printer: a #GtkPrinter
 * 
 * Returns whether the printer is virtual (i.e. does not
 * represent actual printer hardware, but something like 
 * a CUPS class).
 * 
 * Return value: %TRUE if @printer is virtual
 *
 * Since: 2.10
 */
767 768 769 770 771 772 773 774
gboolean
gtk_printer_is_virtual (GtkPrinter *printer)
{
  g_return_val_if_fail (GTK_IS_PRINTER (printer), TRUE);
  
  return printer->priv->is_virtual;
}

775 776 777 778 779 780 781 782 783 784 785
/**
 * gtk_printer_accepts_pdf:
 * @printer: a #GtkPrinter
 *
 * Returns whether the printer accepts input in
 * PDF format.  
 *
 * Return value: %TRUE if @printer accepts PDF
 *
 * Since: 2.10
 */
786 787 788 789 790 791 792 793
gboolean 
gtk_printer_accepts_pdf (GtkPrinter *printer)
{ 
  g_return_val_if_fail (GTK_IS_PRINTER (printer), TRUE);
  
  return printer->priv->accepts_pdf;
}

794 795 796 797 798 799 800 801 802 803 804
/**
 * gtk_printer_accepts_ps:
 * @printer: a #GtkPrinter
 *
 * Returns whether the printer accepts input in
 * PostScript format.  
 *
 * Return value: %TRUE if @printer accepts PostScript
 *
 * Since: 2.10
 */
805 806 807 808 809 810 811 812
gboolean 
gtk_printer_accepts_ps (GtkPrinter *printer)
{ 
  g_return_val_if_fail (GTK_IS_PRINTER (printer), TRUE);
  
  return printer->priv->accepts_ps;
}

813 814 815 816 817 818 819 820 821 822 823 824
gboolean
gtk_printer_is_new (GtkPrinter *printer)
{
  g_return_val_if_fail (GTK_IS_PRINTER (printer), FALSE);
  
  return printer->priv->is_new;
}

void
gtk_printer_set_is_new (GtkPrinter *printer,
			gboolean val)
{
825 826
  g_return_if_fail (GTK_IS_PRINTER (printer));

827 828 829 830
  printer->priv->is_new = val;
}


831 832 833 834 835 836 837 838 839 840
/**
 * gtk_printer_is_default:
 * @printer: a #GtkPrinter
 * 
 * Returns whether the printer is the default printer.
 * 
 * Return value: %TRUE if @printer is the default
 *
 * Since: 2.10
 */
841 842 843 844 845 846 847 848 849 850
gboolean
gtk_printer_is_default (GtkPrinter *printer)
{
  g_return_val_if_fail (GTK_IS_PRINTER (printer), FALSE);
  
  return printer->priv->is_default;
}

void
gtk_printer_set_is_default (GtkPrinter *printer,
851
			    gboolean    val)
852
{
853 854
  g_return_if_fail (GTK_IS_PRINTER (printer));

855 856 857
  printer->priv->is_default = TRUE;
}

858 859 860 861 862
/**
 * gtk_printer_request_details:
 * @printer: a #GtkPrinter
 * 
 * Requests the printer details. When the details are available,
Matthias Clasen's avatar
Matthias Clasen committed
863
 * the #GtkPrinter::details-acquired signal will be emitted on @printer.
864 865 866
 * 
 * Since: 2.12
 */
867
void
868
gtk_printer_request_details (GtkPrinter *printer)
869
{
870 871 872 873 874
  GtkPrintBackendClass *backend_class;

  g_return_if_fail (GTK_IS_PRINTER (printer));

  backend_class = GTK_PRINT_BACKEND_GET_CLASS (printer->priv->backend);
875
  backend_class->printer_request_details (printer);
876 877 878
}

GtkPrinterOptionSet *
879 880 881 882
_gtk_printer_get_options (GtkPrinter           *printer,
			  GtkPrintSettings     *settings,
			  GtkPageSetup         *page_setup,
			  GtkPrintCapabilities  capabilities)
883
{
Alexander Larsson's avatar
Alexander Larsson committed
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 889 890 891
}

gboolean
_gtk_printer_mark_conflicts (GtkPrinter          *printer,
			     GtkPrinterOptionSet *options)
{
Alexander Larsson's avatar
Alexander Larsson committed
892 893
  GtkPrintBackendClass *backend_class = GTK_PRINT_BACKEND_GET_CLASS (printer->priv->backend);
  return backend_class->printer_mark_conflicts (printer, options);
894 895 896 897 898 899 900
}
  
void
_gtk_printer_get_settings_from_options (GtkPrinter          *printer,
					GtkPrinterOptionSet *options,
					GtkPrintSettings    *settings)
{
Alexander Larsson's avatar
Alexander Larsson committed
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 907
_gtk_printer_prepare_for_print (GtkPrinter       *printer,
				GtkPrintJob      *print_job,
908
				GtkPrintSettings *settings,
909
				GtkPageSetup     *page_setup)
910
{
Alexander Larsson's avatar
Alexander Larsson committed
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 917 918 919
_gtk_printer_create_cairo_surface (GtkPrinter       *printer,
				   GtkPrintSettings *settings,
				   gdouble           width, 
				   gdouble           height,
920
				   GIOChannel       *cache_io)
921
{
Alexander Larsson's avatar
Alexander Larsson committed
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:
Matthias Clasen's avatar
Matthias Clasen committed
930
 * @printer: a #GtkPrinter
931
 * 
932
 * Lists all the paper sizes @printer supports.
Matthias Clasen's avatar
Matthias Clasen committed
933 934
 * This will return and empty list unless the printer's details are 
 * available, see gtk_printer_has_details() and gtk_printer_request_details().
935
 * 
Matthias Clasen's avatar
Matthias Clasen committed
936
 * Return value: a newly allocated list of newly allocated #GtkPageSetup s.
937 938 939
 *
 * Since: 2.12
 */
940
GList  *
941
gtk_printer_list_papers (GtkPrinter *printer)
942
{
943 944 945
  GtkPrintBackendClass *backend_class;

  g_return_val_if_fail (GTK_IS_PRINTER (printer), NULL);
946

947
  backend_class = GTK_PRINT_BACKEND_GET_CLASS (printer->priv->backend);
Alexander Larsson's avatar
Alexander Larsson committed
948
  return backend_class->printer_list_papers (printer);
949 950
}

951 952 953 954 955 956 957 958 959 960 961 962 963 964 965 966 967 968 969 970 971
/**
 * gtk_printer_get_default_page_size:
 * @printer: a #GtkPrinter
 * 
 * Returns default page size of @printer.
 * 
 * Return value: a newly allocated #GtkPageSetup with default page size of the printer.
 *
 * Since: 2.13
 */
GtkPageSetup  *
gtk_printer_get_default_page_size (GtkPrinter *printer)
{
  GtkPrintBackendClass *backend_class;

  g_return_val_if_fail (GTK_IS_PRINTER (printer), NULL);

  backend_class = GTK_PRINT_BACKEND_GET_CLASS (printer->priv->backend);
  return backend_class->printer_get_default_page_size (printer);
}

972
void
973 974 975 976 977
_gtk_printer_get_hard_margins (GtkPrinter *printer,
			       gdouble    *top,
			       gdouble    *bottom,
			       gdouble    *left,
			       gdouble    *right)
978
{
Alexander Larsson's avatar
Alexander Larsson committed
979
  GtkPrintBackendClass *backend_class = GTK_PRINT_BACKEND_GET_CLASS (printer->priv->backend);
980

Alexander Larsson's avatar
Alexander Larsson committed
981 982 983
  backend_class->printer_get_hard_margins (printer, top, bottom, left, right);
}

984 985 986 987 988 989
/**
 * gtk_printer_get_capabilities:
 * @printer: a #GtkPrinter
 * 
 * Returns the printer's capabilities.
 *
Matthias Clasen's avatar
Matthias Clasen committed
990 991 992
 * This is useful when you're using #GtkPrintUnixDialog's manual-capabilities 
 * setting and need to know which settings the printer can handle and which 
 * you must handle yourself.
993 994 995 996 997 998 999 1000
 *
 * This will return 0 unless the printer's details are available, see
 * gtk_printer_has_details() and gtk_printer_request_details().
 *  *
 * Return value: the printer's capabilities
 *
 * Since: 2.12
 */
1001
GtkPrintCapabilities
1002
gtk_printer_get_capabilities (GtkPrinter *printer)
1003
{
1004
  GtkPrintBackendClass *backend_class;
1005

1006 1007 1008
  g_return_val_if_fail (GTK_IS_PRINTER (printer), 0);

  backend_class = GTK_PRINT_BACKEND_GET_CLASS (printer->priv->backend);
1009 1010 1011
  return backend_class->printer_get_capabilities (printer);
}

1012 1013 1014 1015 1016 1017 1018 1019 1020 1021 1022 1023
/**
 * gtk_printer_compare:
 * @a: a #GtkPrinter
 * @b: another #GtkPrinter
 *
 * Compares two printers.
 * 
 * Return value: 0 if the printer match, a negative value if @a &lt; @b, 
 *   or a positive value if @a &gt; @b
 *
 * Since: 2.10
 */
Alexander Larsson's avatar
Alexander Larsson committed
1024
gint
1025 1026
gtk_printer_compare (GtkPrinter *a, 
                     GtkPrinter *b)
Alexander Larsson's avatar
Alexander Larsson committed
1027 1028 1029 1030 1031 1032 1033 1034 1035 1036 1037 1038 1039 1040 1041
{
  const char *name_a, *name_b;
  
  g_assert (GTK_IS_PRINTER (a) && GTK_IS_PRINTER (b));
  
  name_a = gtk_printer_get_name (a);
  name_b = gtk_printer_get_name (b);
  if (name_a == NULL  && name_b == NULL)
    return 0;
  else if (name_a == NULL)
    return G_MAXINT;
  else if (name_b == NULL)
    return G_MININT;
  else
    return g_ascii_strcasecmp (name_a, name_b);
1042 1043
}

Matthias Clasen's avatar
Matthias Clasen committed
1044 1045 1046 1047 1048 1049 1050 1051 1052 1053 1054 1055 1056 1057 1058 1059 1060 1061 1062 1063 1064 1065 1066 1067 1068

typedef struct 
{
  GList *backends;
  GtkPrinterFunc func;
  gpointer data;
  GDestroyNotify destroy;
  GMainLoop *loop;
} PrinterList;

static void list_done_cb (GtkPrintBackend *backend, 
			  PrinterList     *printer_list);

static void
stop_enumeration (PrinterList *printer_list)
{
  GList *list, *next;
  GtkPrintBackend *backend;

  for (list = printer_list->backends; list; list = next)
    {
      next = list->next;
      backend = GTK_PRINT_BACKEND (list->data);
      list_done_cb (backend, printer_list);
    }
1069
}
Matthias Clasen's avatar
Matthias Clasen committed
1070

1071 1072 1073
static void 
free_printer_list (PrinterList *printer_list)
{
Matthias Clasen's avatar
Matthias Clasen committed
1074 1075 1076 1077 1078 1079 1080 1081 1082 1083 1084 1085
  if (printer_list->destroy)
    printer_list->destroy (printer_list->data);

  if (printer_list->loop)
    {    
      g_main_loop_quit (printer_list->loop);
      g_main_loop_unref (printer_list->loop);
    }

  g_free (printer_list);
}

1086
static gboolean
Matthias Clasen's avatar
Matthias Clasen committed
1087 1088 1089 1090 1091
list_added_cb (GtkPrintBackend *backend, 
	       GtkPrinter      *printer, 
	       PrinterList     *printer_list)
{
  if (printer_list->func (printer, printer_list->data))
1092 1093 1094 1095 1096 1097
    {
      stop_enumeration (printer_list);
      return TRUE;
    }

  return FALSE;
Matthias Clasen's avatar
Matthias Clasen committed
1098 1099 1100 1101 1102 1103 1104 1105 1106 1107 1108 1109 1110 1111 1112
}

static void
list_done_cb (GtkPrintBackend *backend, 
	      PrinterList     *printer_list)
{
  printer_list->backends = g_list_remove (printer_list->backends, backend);
  
  g_signal_handlers_disconnect_by_func (backend, list_added_cb, printer_list);
  g_signal_handlers_disconnect_by_func (backend, list_done_cb, printer_list);
  
  gtk_print_backend_destroy (backend);
  g_object_unref (backend);

  if (printer_list->backends == NULL)
1113
    free_printer_list (printer_list);
Matthias Clasen's avatar
Matthias Clasen committed
1114 1115
}

1116
static gboolean
Matthias Clasen's avatar
Matthias Clasen committed
1117 1118 1119
list_printers_init (PrinterList     *printer_list,
		    GtkPrintBackend *backend)
{
1120
  GList *list, *node;
Matthias Clasen's avatar
Matthias Clasen committed
1121 1122 1123 1124

  list = gtk_print_backend_get_printer_list (backend);

  for (node = list; node != NULL; node = node->next)
1125 1126 1127 1128 1129 1130 1131
    {
      if (list_added_cb (backend, node->data, printer_list))
        {
          g_list_free (list);
          return TRUE;
        }
    }
Matthias Clasen's avatar
Matthias Clasen committed
1132 1133 1134 1135 1136 1137 1138 1139 1140 1141 1142 1143 1144 1145 1146 1147 1148 1149 1150

  g_list_free (list);

  if (gtk_print_backend_printer_list_is_done (backend))
    {
      printer_list->backends = g_list_remove (printer_list->backends, backend);
      gtk_print_backend_destroy (backend);
      g_object_unref (backend);
    }
  else
    {
      g_signal_connect (backend, "printer-added", 
			(GCallback) list_added_cb, 
			printer_list);
      g_signal_connect (backend, "printer-list-done", 
			(GCallback) list_done_cb, 
			printer_list);
    }

1151
  return FALSE;
Matthias Clasen's avatar
Matthias Clasen committed
1152 1153 1154 1155 1156 1157 1158 1159 1160 1161
}

/**
 * gtk_enumerate_printers:
 * @func: a function to call for each printer
 * @data: user data to pass to @func
 * @destroy: function to call if @data is no longer needed
 * @wait: if %TRUE, wait in a recursive mainloop until
 *    all printers are enumerated; otherwise return early
 *
Matthias Clasen's avatar
Matthias Clasen committed
1162 1163
 * Calls a function for all #GtkPrinter<!-- -->s. 
 * If @func returns %TRUE, the enumeration is stopped.
Matthias Clasen's avatar
Matthias Clasen committed
1164 1165 1166 1167 1168 1169 1170 1171 1172 1173
 *
 * Since: 2.10
 */
void
gtk_enumerate_printers (GtkPrinterFunc func,
			gpointer       data,
			GDestroyNotify destroy,
			gboolean       wait)
{
  PrinterList *printer_list;
Matthias Clasen's avatar
Matthias Clasen committed
1174
  GList *node, *next;
Matthias Clasen's avatar
Matthias Clasen committed
1175 1176 1177 1178 1179 1180 1181 1182 1183 1184
  GtkPrintBackend *backend;

  printer_list = g_new0 (PrinterList, 1);

  printer_list->func = func;
  printer_list->data = data;
  printer_list->destroy = destroy;

  if (g_module_supported ())
    printer_list->backends = gtk_print_backend_load_modules ();
1185 1186 1187 1188 1189 1190
  
  if (printer_list->backends == NULL)
    {
      free_printer_list (printer_list);
      return;
    }
Matthias Clasen's avatar
Matthias Clasen committed
1191 1192 1193 1194 1195

  for (node = printer_list->backends; node != NULL; node = next)
    {
      next = node->next;
      backend = GTK_PRINT_BACKEND (node->data);
1196 1197
      if (list_printers_init (printer_list, backend))
        return;
Matthias Clasen's avatar
Matthias Clasen committed
1198 1199 1200 1201 1202 1203 1204 1205 1206 1207 1208 1209
    }

  if (wait && printer_list->backends)
    {
      printer_list->loop = g_main_loop_new (NULL, FALSE);

      GDK_THREADS_LEAVE ();  
      g_main_loop_run (printer_list->loop);
      GDK_THREADS_ENTER ();  
    }
}

1210 1211 1212 1213 1214 1215 1216 1217 1218 1219 1220 1221 1222 1223 1224 1225
GType
gtk_print_capabilities_get_type (void)
{
  static GType etype = 0;

  if (G_UNLIKELY (etype == 0))
    {
      static const GFlagsValue values[] = {
        { GTK_PRINT_CAPABILITY_PAGE_SET, "GTK_PRINT_CAPABILITY_PAGE_SET", "page-set" },
        { GTK_PRINT_CAPABILITY_COPIES, "GTK_PRINT_CAPABILITY_COPIES", "copies" },
        { GTK_PRINT_CAPABILITY_COLLATE, "GTK_PRINT_CAPABILITY_COLLATE", "collate" },
        { GTK_PRINT_CAPABILITY_REVERSE, "GTK_PRINT_CAPABILITY_REVERSE", "reverse" },
        { GTK_PRINT_CAPABILITY_SCALE, "GTK_PRINT_CAPABILITY_SCALE", "scale" },
        { GTK_PRINT_CAPABILITY_GENERATE_PDF, "GTK_PRINT_CAPABILITY_GENERATE_PDF", "generate-pdf" },
        { GTK_PRINT_CAPABILITY_GENERATE_PS, "GTK_PRINT_CAPABILITY_GENERATE_PS", "generate-ps" },
        { GTK_PRINT_CAPABILITY_PREVIEW, "GTK_PRINT_CAPABILITY_PREVIEW", "preview" },
1226
	{ GTK_PRINT_CAPABILITY_NUMBER_UP, "GTK_PRINT_CAPABILITY_NUMBER_UP", "number-up"},
1227 1228 1229 1230 1231 1232 1233 1234 1235
        { 0, NULL, NULL }
      };

      etype = g_flags_register_static (I_("GtkPrintCapabilities"), values);
    }

  return etype;
}

Matthias Clasen's avatar
Matthias Clasen committed
1236

1237 1238
#define __GTK_PRINTER_C__
#include "gtkaliasdef.c"