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